diff --git a/multimedia/BUILD.gn b/multimedia/BUILD.gn index 4c3ad2ef6a43f4513b23d9283f227056176a94e1..c20628aaa8f2c42199d9f2b21eaf560e5d13b32c 100644 --- a/multimedia/BUILD.gn +++ b/multimedia/BUILD.gn @@ -47,6 +47,7 @@ group("multimedia") { "media/media_js_standard/audioRecorder:audio_recorder_js_hap", "media/media_js_standard/recorderFormat:recorder_format_js_hap", "media/media_js_standard/videoPlayer:video_player_js_hap", + "media/media_js_standard/avPlayer:avplayer_js_hap", "medialibrary/mediaLibrary_album:mediaLibrary_album_hap", "medialibrary/mediaLibrary_base:mediaLibrary_base_hap", "medialibrary/mediaLibrary_favorite:mediaLibrary_favorite_hap", diff --git a/multimedia/media/media_js_standard/AVPlayerTestBase.js b/multimedia/media/media_js_standard/AVPlayerTestBase.js new file mode 100644 index 0000000000000000000000000000000000000000..00d530881f13ed703012af0937ea78aa8053cda2 --- /dev/null +++ b/multimedia/media/media_js_standard/AVPlayerTestBase.js @@ -0,0 +1,575 @@ +/* + * 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 media from '@ohos.multimedia.media' +import * as mediaTestBase from './MediaTestBase.js'; + +export const AV_PLAYER_STATE = { + IDLE : 'idle', + INITIALIZED : 'initialized', + PREPARED : 'prepared', + PLAYING : 'playing', + PAUSED : 'paused', + COMPLETED : 'completed', + STOPPED : 'stopped', + RELEASED : 'released', + ERROR : 'error', +} + +let playTest = { + width: 0, + height: 0, + duration: -1 +} +export {playTest}; + +export function setSource(avPlayer, src) { + if (typeof(avPlayer) == 'undefined') { + console.error('case avPlayer is undefined'); + return; + } + if (typeof(src) == 'string') { + console.info('case src test'); + avPlayer.url = src; + } else { + console.info('case fdsrc test'); + avPlayer.fdSrc = src; + } +} + +function checkPlayTest(avPlayer, playTest) { + if (avPlayer == null) { + return; + } + expect(Math.abs(avPlayer.duration - playTest.duration)).assertLess(500); + if (playTest.width > 0) { + expect(avPlayer.width).assertEqual(playTest.width); + expect(avPlayer.height).assertEqual(playTest.height); + } +} + +function toPreparePromise(avPlayer, playTest) { + if (typeof(avPlayer) == 'undefined') { + return; + } + avPlayer.prepare().then(() => { + console.info('case prepare called'); + console.info('case avPlayer.duration: ' + avPlayer.duration); + checkPlayTest(avPlayer, playTest); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); +} + +function addCnt(countArr) { + if (countArr != null) { + countArr[0]++; + } +} + +export function setCallback(avPlayer, type, countArr) { + if (avPlayer == null) { + return; + } + switch (type) { + case 'volumeChange': + avPlayer.on('volumeChange', (volume) => { + console.info(`case volumeChange called, volume is ${volume}`); + addCnt(countArr); + }); + break; + case 'endOfStream': + avPlayer.on('endOfStream', () => { + console.info(`case endOfStream called`); + addCnt(countArr); + }); + break; + case 'speedDone': + avPlayer.on('speedDone', (speedMode) => { + console.info(`case speedDone called, speedMode is ${speedMode}`); + addCnt(countArr); + }); + break; + case 'bitrateDone': + avPlayer.on('bitrateDone', (bitrate) => { + console.info(`case bitrateDone called, bitrate is ${bitrate}`); + }); + break; + case 'timeUpdate': + avPlayer.on('timeUpdate', (time) => { + console.info('case timeUpdate callback, time:' + time); + }); + break; + case 'bufferingUpdate': + avPlayer.on('bufferingUpdate', (infoType, value) => { + }); + break; + case 'durationUpdate': + avPlayer.on('durationUpdate', (duration) => { + console.info('case durationUpdate called,duration:' + duration); + addCnt(countArr); + }); + break; + case 'startRenderFrame': + avPlayer.on('startRenderFrame', () => { + console.info('case startRenderFrame called'); + addCnt(countArr); + }); + break; + case 'videoSizeChange': + avPlayer.on('videoSizeChange', (w, h) => { + console.info(`case videoSizeChange called, weight is ${w}, height is ${h}`); + addCnt(countArr); + }); + break; + case 'audioInterrupt': + avPlayer.on('audioInterrupt', (info) => { + console.info(`case audioInterrupt called, info is ${info}`); + }); + break; + case 'availableBitrates': + avPlayer.on('availableBitrates', (bitrates) => { + for (let i = 0; i < bitrates.length; i++) { + console.info('case availableBitrates : ' + bitrates[i]); + } + addCnt(countArr); + }); + break; + default: + break; + } +} + +export function offCallback(avPlayer, typeArr) +{ + if (avPlayer == null) { + return; + } + for (let i = 0; i < typeArr.length; i++) { + switch (typeArr[i]) { + case 'stateChange': + avPlayer.off('stateChange'); + break; + case 'volumeChange': + avPlayer.off('volumeChange'); + break; + case 'endOfStream': + avPlayer.off('endOfStream'); + break; + case 'seekDone': + avPlayer.off('seekDone'); + break; + case 'speedDone': + avPlayer.off('speedDone'); + break; + case 'speedDone': + avPlayer.off('speedDone'); + break; + case 'timeUpdate': + avPlayer.off('timeUpdate'); + break; + case 'durationUpdate': + avPlayer.off('durationUpdate'); + break; + case 'bufferingUpdate': + avPlayer.off('bufferingUpdate'); + break; + case 'startRenderFrame': + avPlayer.off('startRenderFrame'); + break; + case 'videoSizeChange': + avPlayer.off('videoSizeChange'); + break; + case 'audioInterrupt': + avPlayer.off('audioInterrupt'); + break; + case 'availableBitrates': + avPlayer.off('availableBitrates'); + break; + case 'error': + avPlayer.off('error'); + break; + default: + break; + } + } +} + +export function setAVPlayerFunCb(src, avPlayer, playTest, playTime, done) { + let volumeCnt = [0]; + let endOfStreamCnt = [0]; + let speedDoneCnt = [0]; + let videoSizeCnt = [0]; + let startRenderFrameCnt = [0]; + let durationUpdateCnt = [0]; + let seekDoneCnt = [0]; + let prepareCnt = 0; + let playCnt = 0; + let completedCnt = 0; + let surfaceID = globalThis.value; + console.info(`case setAVPlayerFunCb in, surfaceID is ${surfaceID}`); + avPlayer.on('stateChange', async (state, reason) => { + console.info(`case stateChange called, state is ${state}, reason is ${reason}`); + if (reason == media.StateChangeReason.BACKGROUND) { + console.info(`case media.StateChangeReason.BACKGROUND`); + await avPlayer.release().then(() => { + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + } + console.info(`case state is ${state}`); + switch (state) { + case AV_PLAYER_STATE.INITIALIZED: + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.INITIALIZED); + avPlayer.surfaceId = surfaceID; + // step 1, 13: initialized -> prepared + toPreparePromise(avPlayer, playTest); + break; + case AV_PLAYER_STATE.PREPARED: + prepareCnt++; + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); + checkPlayTest(avPlayer, playTest); + expect(avPlayer.currentTime).assertEqual(0); + if (prepareCnt == 1) { + // step 2: prepared -> playing + avPlayer.play().then(() => { + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + } else { + // step 14: prepared -> seek + avPlayer.seek(avPlayer.duration); + } + break; + case AV_PLAYER_STATE.PLAYING: + playCnt++; + if (playCnt == 1) { + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); + // step 3: playing -> seek duration/3 + await mediaTestBase.msleepAsync(playTime); + avPlayer.seek(avPlayer.duration / 3); + } else if (playCnt == 2) { + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); + // step 7: playing -> seek duration when loop true + avPlayer.seek(avPlayer.duration, media.SeekMode.SEEK_NEXT_SYNC); + } else if (playCnt == 3) { + // step 10: playing -> stop + avPlayer.stop().then(() => { + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + } + break; + case AV_PLAYER_STATE.PAUSED: + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED); + // step 5: pause -> seek 0 + avPlayer.loop = true; + avPlayer.seek(0, media.SeekMode.SEEK_NEXT_SYNC); + break; + case AV_PLAYER_STATE.COMPLETED: + completedCnt++; + expect(avPlayer.currentTime).assertEqual(avPlayer.duration); + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.COMPLETED); + if (completedCnt == 1) { + // step 9: completed -> play + avPlayer.play(); + } else { + // step 16: completed -> reset + avPlayer.reset().then(() => { + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE); + // step 17: reset -> release + avPlayer.release().then(() => { + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + } + break; + case AV_PLAYER_STATE.STOPPED: + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.STOPPED); + // step 11: stop -> reset + avPlayer.reset().then(() => { + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE); + // step 12: reset -> initialized + setSource(avPlayer, src); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + break; + case AV_PLAYER_STATE.RELEASED: + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + offCallback(avPlayer, ['stateChange', 'volumeChange', 'endOfStream', 'seekDone', 'speedDone', + 'bitrateDone', 'timeUpdate', 'durationUpdate', 'bufferingUpdate', 'startRenderFrame', 'videoSizeChange', + 'audioInterrupt', 'availableBitrates', 'error']); + // step 18: release -> done + avPlayer = null; + expect(volumeCnt[0]).assertLarger(0); + expect(endOfStreamCnt[0]).assertLarger(0); + expect(seekDoneCnt[0]).assertLarger(0); + expect(speedDoneCnt[0]).assertLarger(0); + expect(completedCnt).assertLarger(0); + if (playTest.width != 0) { + expect(startRenderFrameCnt[0]).assertLarger(0); + expect(videoSizeCnt[0]).assertLarger(0); + } else { + expect(startRenderFrameCnt[0]).assertEqual(0); + expect(videoSizeCnt[0]).assertEqual(0); + } + expect(durationUpdateCnt[0]).assertLarger(0) + done(); + break; + case AV_PLAYER_STATE.ERROR: + expect().assertFail(); + avPlayer.release().then(() => { + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + break; + default: + break; + } + }); + avPlayer.on('seekDone', async (seekDoneTime) => { + seekDoneCnt[0]++; + console.info(`case seekDone called, seekDoneCnt is ${seekDoneCnt}, seekDoneTime is ${seekDoneTime}`); + switch (seekDoneCnt[0]) { + case 2: + // step 6: seek(paused) -> play + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED); + avPlayer.play(); + avPlayer.setSpeed(media.PlaybackSpeed.SPEED_FORWARD_2_00_X); + avPlayer.setVolume(0.5); + break; + case 1: + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); + // step 4: seek(playing) -> pause + avPlayer.pause().then(() => { + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + break; + case 3: + case 4: + case 5: + let nowTime = avPlayer.currentTime; + if (avPlayer.state == AV_PLAYER_STATE.PREPARED) { + // step 15: prepared -> play + avPlayer.play(); + } + if (nowTime > avPlayer.duration / 2) { + avPlayer.setSpeed(media.PlaybackSpeed.SPEED_FORWARD_1_00_X); + await mediaTestBase.msleepAsync(avPlayer.duration - nowTime + playTime); + } + if (avPlayer.loop == true) { + // step 8: playing -> seek duration when loop false + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); + avPlayer.loop = false; + avPlayer.seek(avPlayer.duration, media.SeekMode.SEEK_NEXT_SYNC); + } + break; + } + }); + setCallback(avPlayer, 'volumeChange', volumeCnt); + setCallback(avPlayer, 'endOfStream', endOfStreamCnt); + setCallback(avPlayer, 'speedDone', speedDoneCnt); + setCallback(avPlayer, 'bitrateDone', null); + setCallback(avPlayer, 'timeUpdate', null); + setCallback(avPlayer, 'bufferingUpdate', null); + setCallback(avPlayer, 'durationUpdate', durationUpdateCnt); + setCallback(avPlayer, 'startRenderFrame', startRenderFrameCnt); + setCallback(avPlayer, 'videoSizeChange', videoSizeCnt); + setCallback(avPlayer, 'audioInterrupt', null); + setCallback(avPlayer, 'availableBitrates', null); + avPlayer.on('error', async (err) => { + console.error(`case error called, errMessage is ${err.message}`); + expect().assertFail(); + await avPlayer.release().then(() => { + avPlayer = null; + done(); + }); + }); +} + +export async function testAVPlayerFun(src, avPlayer, playTest, playTime, done) { + console.info(`case media source: ${src}`) + await media.createAVPlayer().then((video) => { + if (typeof(video) != 'undefined') { + console.info('case createAVPlayer success'); + avPlayer = video; + } else { + console.error('case createAVPlayer failed'); + expect().assertFail(); + done(); + } + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + setAVPlayerFunCb(src, avPlayer, playTest, playTime, done); + setSource(avPlayer, src); +} + +export function setAVPlayerSeekCb(src, avPlayer, playTest, playTime, done) { + let volumeCnt = [0]; + let endOfStreamCnt = 0; + let seekDoneCnt = 0; + let speedDoneCnt = [0]; + let playCnt = 0; + let surfaceID = globalThis.value; + console.info(`case setCallback in, surfaceID is ${surfaceID}`); + avPlayer.on('stateChange', async (state, reason) => { + console.info(`case stateChange called, state is ${state}, reason is ${reason}`); + if (reason == media.StateChangeReason.BACKGROUND) { + avPlayer.release().then(() => { + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + } + switch (state) { + case AV_PLAYER_STATE.INITIALIZED: + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.INITIALIZED); + avPlayer.surfaceId = surfaceID; + console.info('case initialized -> prepared'); + // step 1,10: initialized -> prepared + avPlayer.prepare((err) => { + avPlayer.loop = true; + if (err != null) { + console.error(`case prepare error, errMessage is ${err.message}`); + expect().assertFail(); + done(); + } else { + checkPlayTest(avPlayer, playTest); + } + }); + break; + case AV_PLAYER_STATE.PREPARED: + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); + checkPlayTest(avPlayer, playTest); + expect(avPlayer.currentTime).assertEqual(0); + offCallback(avPlayer, ['volumeChange']); + // step 2,11: prepared -> seek 0 + avPlayer.seek(0, 2); // 2: CLOSEST SYNC + break; + case AV_PLAYER_STATE.PLAYING: + playCnt++; + if (playCnt == 1) { + // step 4: seek + pause + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); + avPlayer.seek(avPlayer.duration / 2, media.SeekMode.SEEK_PREV_SYNC); + // avPlayer.pause(); + avPlayer.pause((err) => { + if (err != null) { + mediaTestBase.assertErr('pause', err, done); + } + }); + } else if (playCnt == 3) { + // step 12: seek duration + avPlayer.seek(avPlayer.duration, media.SeekMode.SEEK_PREV_SYNC); + avPlayer.stop((err) => { + if (err == null) { + avPlayer.release((err) => { + if (err != null) { + mediaTestBase.assertErr('release', err, done); + } + }) + } else { + mediaTestBase.assertErr('stop', err, done); + } + }); + } + break; + case AV_PLAYER_STATE.RELEASED: + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + // step 18: release -> done + avPlayer = null; + expect(volumeCnt[0]).assertEqual(0); + expect(endOfStreamCnt).assertLarger(0); + done(); + break; + case AV_PLAYER_STATE.ERROR: + expect().assertFail(); + avPlayer.release().then(() => { + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + break; + default: + break; + } + }); + + avPlayer.on('endOfStream', () => { + console.info(`case endOfStream called`); + endOfStreamCnt++; + // step 9: seek + reset + avPlayer.seek(avPlayer.duration / 2, 3); // 3: CLOSEST + avPlayer.reset((err) => { + if (err == null) { + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE); + console.info('case reset success!!'); + setSource(avPlayer, src); + } else { + mediaTestBase.assertErr('reset', err, done); + } + }); + }); + avPlayer.on('seekDone', async (seekDoneTime) => { + seekDoneCnt++; + console.info(`case seekDone called, seekDoneCnt is ${seekDoneCnt}, seekDoneTime is ${seekDoneTime}`); + switch (seekDoneCnt) { + case 1: + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); + // step 3: seek(prepared) -> play + avPlayer.play((err) => { + if (err != null) { + mediaTestBase.assertErr('play', err, done); + } + }); + break; + case 2: + // step 5: seek + play + avPlayer.seek(avPlayer.duration / 2, media.SeekMode.SEEK_NEXT_SYNC); + avPlayer.play(); + break; + case 3: + // step 6: seek + setVolume + avPlayer.setVolume(0.5); + avPlayer.seek(avPlayer.duration / 2, media.SeekMode.SEEK_CLOSEST_SYNC); + avPlayer.play(); + break; + case 4: + // step 7: seek + seek + avPlayer.seek(avPlayer.duration / 2); + avPlayer.seek(avPlayer.duration, media.SeekMode.SEEK_NEXT_SYNC); + avPlayer.play(); + break; + case 5: + // step 8: seek duration + avPlayer.seek(avPlayer.duration, media.SeekMode.SEEK_PREV_SYNC); + break; + default: + avPlayer.play(); + break; + } + }); + setCallback(avPlayer, 'volumeChange', volumeCnt); + setCallback(avPlayer, 'speedDone', speedDoneCnt); + setCallback(avPlayer, 'bitrateDone', null); + setCallback(avPlayer, 'timeUpdate', null); + setCallback(avPlayer, 'bufferingUpdate', null); + setCallback(avPlayer, 'durationUpdate', null); + setCallback(avPlayer, 'startRenderFrame', null); + setCallback(avPlayer, 'videoSizeChange', null); + setCallback(avPlayer, 'audioInterrupt', null); + setCallback(avPlayer, 'availableBitrates', null); + avPlayer.on('error', async (err) => { + console.error(`case error called, errMessage is ${err.message}`); + }); +} + +export async function testAVPlayerSeek(src, avPlayer, playTest, playTime, done) { + console.info(`case media source: ${src}`) + media.createAVPlayer((err, video) => { + console.info(`case media err: ${err}`) + if (typeof(video) != 'undefined') { + console.info('case createAVPlayer success'); + avPlayer = video; + setAVPlayerSeekCb(src, avPlayer, playTest, playTime, done); + setSource(avPlayer, src); + } + if (err != null) { + console.error(`case createAVPlayer error, errMessage is ${err.message}`); + expect().assertFail(); + done(); + } + }); +} diff --git a/multimedia/media/media_js_standard/MediaTestBaseAV.js b/multimedia/media/media_js_standard/MediaTestBaseAV.js new file mode 100644 index 0000000000000000000000000000000000000000..ddf517bea4f429e66a6cfc618d3aa2adc40c7fb2 --- /dev/null +++ b/multimedia/media/media_js_standard/MediaTestBaseAV.js @@ -0,0 +1,144 @@ +/* + * 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 featureAbility from '@ohos.ability.featureAbility' +import { UiDriver, BY, PointerMatrix } from '@ohos.uitest' +const CODECMIMEVALUE = ['video/avc', 'audio/mp4a-latm', 'audio/mpeg'] + +export async function getPermission(permissionNames) { + featureAbility.getContext().requestPermissionsFromUser(permissionNames, 0, async (data) => { + console.info("case request success" + JSON.stringify(data)); + }) +} + +export async function driveFn(num) { + console.info(`case come in driveFn 111`); + let driver = UiDriver.create(); + console.info(`case come in driveFn 222`); + console.info(`driver is ${JSON.stringify(driver)}`); + await msleepAsync(2000); + console.info(`UiDriver start`); + for (let i = 0; i < num; i++) { + let button = await driver.findComponent(BY.text('允许')); + console.info(`button is ${JSON.stringify(button)}`); + await msleepAsync(2000); + await button.click(); + } + await msleepAsync(2000); +} + +// File operation +export async function getFileDescriptor(fileName) { + let fileDescriptor = undefined; + let mgr = globalThis.abilityContext.resourceManager + await mgr.getRawFileDescriptor(fileName).then(value => { + fileDescriptor = {fd: value.fd, offset: value.offset, length: value.length}; + console.log('case getRawFileDescriptor success fileName: ' + fileName); + }).catch(error => { + console.log('case getRawFileDescriptor err: ' + error); + }); + return fileDescriptor; +} +export async function closeFileDescriptor(fileName) { + await globalThis.abilityContext.resourceManager.closeRawFileDescriptor(fileName).then(()=> { + console.log('case closeRawFileDescriptor ' + fileName); + }).catch(error => { + console.log('case closeRawFileDescriptor err: ' + error); + }); +} + + +// wait asynchronously +export async function msleepAsync(ms) { + return new Promise((resolve) => setTimeout(resolve, ms)); +} + +export function assertErr(opera, err, done) { + console.info(`case ${opera} error,errMessage is ${err.message}`); + expect().assertFail(); + done(); +} +// callback function for promise call back error +export function failureCallback(error) { + expect().assertFail(); + console.info(`case failureCallback promise called,errMessage is ${error.message}`); +} + +// callback function for promise catch error +export function catchCallback(error) { + expect().assertFail(); + console.info(`case error catch called,errMessage is ${error.message}`); +} +export function checkDescription(actualDescription, descriptionKey, descriptionValue) { + for (let i = 0; i < descriptionKey.length; i++) { + let property = actualDescription[descriptionKey[i]]; + console.info('case key is '+ descriptionKey[i]); + console.info('case actual value is '+ property); + console.info('case hope value is '+ descriptionValue[i]); + if (descriptionKey[i] == 'codec_mime') { + expect(property).assertEqual(CODECMIMEVALUE[descriptionValue[i]]); + } else { + expect(property).assertEqual(descriptionValue[i]); + } + + } +} + + +export async function getFd(pathName, fileType) { + let fdObject = { + fileAsset : null, + fdNumber : null + } + let displayName = pathName; + console.info('[mediaLibrary] fileType is ' + fileType); + const mediaTest = mediaLibrary.getMediaLibrary(globalThis.abilityContext); + let fileKeyObj = mediaLibrary.FileKey; + let mediaType; + let publicPath; + if (fileType == 'audio') { + mediaType = mediaLibrary.MediaType.AUDIO; + publicPath = await mediaTest.getPublicDirectory(mediaLibrary.DirectoryType.DIR_AUDIO); + } else { + mediaType = mediaLibrary.MediaType.VIDEO; + publicPath = await mediaTest.getPublicDirectory(mediaLibrary.DirectoryType.DIR_VIDEO); + } + console.info('[mediaLibrary] publicPath is ' + publicPath); + let dataUri = await mediaTest.createAsset(mediaType, displayName, publicPath); + if (dataUri != undefined) { + let args = dataUri.id.toString(); + let fetchOp = { + selections : fileKeyObj.ID + "=?", + selectionArgs : [args], + } + let fetchFileResult = await mediaTest.getFileAssets(fetchOp); + fdObject.fileAsset = await fetchFileResult.getAllObject(); + fdObject.fdNumber = await fdObject.fileAsset[0].open('rw'); + console.info('case getFd number is: ' + fdObject.fdNumber); + } + return fdObject; +} + +export async function closeFd(fileAsset, fdNumber) { + if (fileAsset != null) { + await fileAsset[0].close(fdNumber).then(() => { + console.info('[mediaLibrary] case close fd success'); + }).catch((err) => { + console.info('[mediaLibrary] case close fd failed'); + }); + } else { + console.info('[mediaLibrary] case fileAsset is null'); + } +} diff --git a/multimedia/media/media_js_standard/avPlayer/AppScope/app.json b/multimedia/media/media_js_standard/avPlayer/AppScope/app.json new file mode 100644 index 0000000000000000000000000000000000000000..f2ea03357b6a08a0b611933b280b8e6ee5a2f4c7 --- /dev/null +++ b/multimedia/media/media_js_standard/avPlayer/AppScope/app.json @@ -0,0 +1,21 @@ +{ + "app":{ + "bundleName":"ohos.acts.multimedia.avplayer", + "vendor":"huawei", + "versionCode":1000000, + "versionName":"1.0.0", + "debug":false, + "icon":"$media:icon", + "label":"$string:app_name", + "description":"$string:description_application", + "distributedNotificationEnabled":true, + "keepAlive":true, + "singleUser":true, + "minAPIVersion":8, + "targetAPIVersion":8, + "car":{ + "apiCompatibleVersion":8, + "singleUser":false + } + } +} diff --git a/multimedia/media/media_js_standard/avPlayer/AppScope/resources/base/element/string.json b/multimedia/media/media_js_standard/avPlayer/AppScope/resources/base/element/string.json new file mode 100644 index 0000000000000000000000000000000000000000..ee69f9a861d9dc269ed6638735d52674583498e1 --- /dev/null +++ b/multimedia/media/media_js_standard/avPlayer/AppScope/resources/base/element/string.json @@ -0,0 +1,8 @@ +{ + "string":[ + { + "name":"app_name", + "value":"ohosProject" + } + ] +} \ No newline at end of file diff --git a/multimedia/media/media_js_standard/avPlayer/AppScope/resources/base/media/app_icon.png b/multimedia/media/media_js_standard/avPlayer/AppScope/resources/base/media/app_icon.png new file mode 100644 index 0000000000000000000000000000000000000000..474a55588fd7216113dd42073aadf254d4dba023 Binary files /dev/null and b/multimedia/media/media_js_standard/avPlayer/AppScope/resources/base/media/app_icon.png differ diff --git a/multimedia/media/media_js_standard/avPlayer/BUILD.gn b/multimedia/media/media_js_standard/avPlayer/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..c74a600ea7238c8e7af7623e81cfdf21555520a9 --- /dev/null +++ b/multimedia/media/media_js_standard/avPlayer/BUILD.gn @@ -0,0 +1,43 @@ +# 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("//test/xts/tools/build/suite.gni") + +ohos_js_hap_suite("avplayer_js_hap") { + hap_profile = "entry/src/main/module.json" + js_build_mode = "debug" + deps = [ + ":ActsAVPlayerTest_js_assets", + ":ActsAVPlayerTest_resources", + ] + ets2abc = true + certificate_profile = "signature/openharmony_sx.p7b" + hap_name = "ActsAVPlayerTest" + subsystem_name = "ability" + part_name = "ability_runtime" +} + +ohos_app_scope("ActsAVPlayerTest_app_profile") { + app_profile = "AppScope/app.json" + sources = [ "AppScope/resources" ] +} + +ohos_js_assets("ActsAVPlayerTest_js_assets") { + source_dir = "entry/src/main/ets" +} + +ohos_resources("ActsAVPlayerTest_resources") { + sources = [ "entry/src/main/resources" ] + deps = [ ":ActsAVPlayerTest_app_profile" ] + hap_profile = "entry/src/main/module.json" +} diff --git a/multimedia/media/media_js_standard/avPlayer/Test.json b/multimedia/media/media_js_standard/avPlayer/Test.json new file mode 100644 index 0000000000000000000000000000000000000000..eccd068baee4160159a04ee6637ccb99acec67a6 --- /dev/null +++ b/multimedia/media/media_js_standard/avPlayer/Test.json @@ -0,0 +1,42 @@ +{ + "description": "Configuration for hjunit demo Tests", + "driver": { + "type": "OHJSUnitTest", + "test-timeout": "180000", + "bundle-name": "ohos.acts.multimedia.avplayer", + "module-name": "phone", + "shell-timeout": "600000", + "testcase-timeout": 70000 + }, + "kits": [ + { + "test-file-name": [ + "ActsAVPlayerTest.hap" + ], + "type": "AppInstallKit", + "cleanup-apps": true + }, + { + "type": "ShellKit", + "run-command": [ + "remount", + "mkdir /data/test" + ] + }, + { + "type": "PushKit", + "push": [ + "ActsAVPlayerTest.hap->/data/ActsAVPlayerTest.hap", + "./resource/audio/H264_AAC.mp4 -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/" + ] + }, + { + "type": "ShellKit", + "run-command": [ + "chmod 644 /data/test/*.hap", + "scanner", + "param set persist.ace.testmode.enabled 1" + ] + } + ] +} \ No newline at end of file diff --git a/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/Application/AbilityStage.ts b/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/Application/AbilityStage.ts new file mode 100644 index 0000000000000000000000000000000000000000..5f88567ba87bf100b2d5227c15ff4987484074c6 --- /dev/null +++ b/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/Application/AbilityStage.ts @@ -0,0 +1,23 @@ +/* + * 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 AbilityStage from "@ohos.app.ability.AbilityStage" + +export default class MyAbilityStage extends AbilityStage { + onCreate() { + console.log("[Demo] MyAbilityStage onCreate") + globalThis.stageOnCreateRun = 1; + globalThis.stageContext = this.context; + } +} diff --git a/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/MainAbility/MainAbility.ts b/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/MainAbility/MainAbility.ts new file mode 100644 index 0000000000000000000000000000000000000000..974a9fd2680f285a9d28e024020968fefaa12873 --- /dev/null +++ b/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/MainAbility/MainAbility.ts @@ -0,0 +1,51 @@ +/* + * 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 Ability from '@ohos.app.ability.UIAbility' + +export default class MainAbility extends Ability { + onCreate(want,launchParam){ + // Ability is creating, initialize resources for this ability + console.log("[Demo] MainAbility onCreate") + globalThis.abilityWant = want; + } + + onDestroy() { + // Ability is destroying, release resources for this ability + console.log("[Demo] MainAbility onDestroy") + } + + onWindowStageCreate(windowStage) { + // Main window is created, set main page for this ability + console.log("[Demo] MainAbility onWindowStageCreate") + globalThis.abilityContext = this.context + console.log("[Demo] MainAbility onWindowStageCreate windowStage="+ windowStage) + windowStage.setUIContent(this.context, "MainAbility/pages/index/index", null) + } + + onWindowStageDestroy() { + //Main window is destroyed, release UI related resources + console.log("[Demo] MainAbility onWindowStageDestroy") + } + + onForeground() { + // Ability has brought to foreground + console.log("[Demo] MainAbility onForeground") + } + + onBackground() { + // Ability has back to background + console.log("[Demo] MainAbility onBackground") + } +}; \ No newline at end of file diff --git a/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/MainAbility/pages/index/index.ets b/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/MainAbility/pages/index/index.ets new file mode 100644 index 0000000000000000000000000000000000000000..2da1ed7b463f8c46284582fe3a36c2af94b3d5a3 --- /dev/null +++ b/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/MainAbility/pages/index/index.ets @@ -0,0 +1,66 @@ +/* + * 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 file from '@system.file'; +import { Core, ExpectExtend, InstrumentLog, ReportExtend } from "deccjsunit/index" +import testsuite from "../../../test/List.test.ets" +import featureAbility from "@ohos.ability.featureAbility" +import { UiDriver, BY } from '@ohos.uitest' + +var mXComponentController: XComponentController = new XComponentController() +var surfaceId: any + +@Entry +@Component +struct Index { + aboutToAppear() { + console.info("start run testcase!!!!"); +} + build() { + Flex() { + XComponent({ + id: 'xcomponent', + type: 'surface', + libraryname: '', + controller: mXComponentController + }) + .onLoad(() => { + console.info('CameraModuleTest: OnLoad() is called!') + mXComponentController.setXComponentSurfaceSize({ surfaceWidth: 1920, surfaceHeight: 1080 }); + surfaceId = mXComponentController.getXComponentSurfaceId() + globalThis.value = surfaceId + console.info('CameraModuleTest: XComponent onLoad surfaceId: ' + globalThis.value) + const core = Core.getInstance() + const expectExtend = new ExpectExtend({ + 'id': 'extend' + }) + core.addService('expect', expectExtend) + const reportExtend = new ReportExtend(file) + + core.addService('report', reportExtend) + core.init() + core.subscribeEvent('task', reportExtend) + const configService = core.getDefaultService('config') + globalThis.abilityWant.parameters.timeout = 70000; + configService.setConfig(globalThis.abilityWant.parameters) + console.info('testsuite()---->') + testsuite() + core.execute() + console.info('core.execute()---->') + }) + .width('1920px') + .height('1080px') + } + } +} \ No newline at end of file diff --git a/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/MainAbility/pages/second/second.ets b/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/MainAbility/pages/second/second.ets new file mode 100644 index 0000000000000000000000000000000000000000..f9009a3e8567d1f4557ebc11dded54c7e27c0b0d --- /dev/null +++ b/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/MainAbility/pages/second/second.ets @@ -0,0 +1,43 @@ +/* + * 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 router from '@system.router'; + +@Entry +@Component +struct Second { + private content: string = "Second Page" + + build() { + Flex({ direction: FlexDirection.Column,alignItems: ItemAlign.Center, justifyContent: FlexAlign.Center }) { + Text(`${this.content}`) + .fontSize(50) + .fontWeight(FontWeight.Bold) + Button() { + Text('back to index') + .fontSize(20) + .fontWeight(FontWeight.Bold) + }.type(ButtonType.Capsule) + .margin({ + top: 20 + }) + .backgroundColor('#0D9FFB') + .onClick(() => { + router.back() + }) + } + .width('100%') + .height('100%') + } +} \ No newline at end of file diff --git a/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/TestAbility/TestAbility.ts b/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/TestAbility/TestAbility.ts new file mode 100644 index 0000000000000000000000000000000000000000..89a84730505783ba229175ab4b55d37f91a16266 --- /dev/null +++ b/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/TestAbility/TestAbility.ts @@ -0,0 +1,50 @@ +/* + * 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 Ability from '@ohos.application.Ability' + +export default class TestAbility extends Ability { + onCreate(want, launchParam) { + console.log('TestAbility onCreate') + } + + onDestroy() { + console.log('TestAbility onDestroy') + } + + onWindowStageCreate(windowStage) { + console.log('TestAbility onWindowStageCreate') + windowStage.loadContent("TestAbility/pages/index", (err, data) => { + if (err.code) { + console.error('Failed to load the content. Cause:' + JSON.stringify(err)); + return; + } + console.info('Succeeded in loading the content. Data: ' + JSON.stringify(data)) + }); + + globalThis.abilityContext = this.context; + } + + onWindowStageDestroy() { + console.log('TestAbility onWindowStageDestroy') + } + + onForeground() { + console.log('TestAbility onForeground') + } + + onBackground() { + console.log('TestAbility onBackground') + } +}; \ No newline at end of file diff --git a/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/TestAbility/pages/index.ets b/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/TestAbility/pages/index.ets new file mode 100644 index 0000000000000000000000000000000000000000..b93567f962921124b282f78c8ef123965d1460c9 --- /dev/null +++ b/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/TestAbility/pages/index.ets @@ -0,0 +1,48 @@ +/* + * 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 router from '@ohos.router'; + +@Entry +@Component +struct Index { + aboutToAppear() { + console.info('TestAbility index aboutToAppear') + } + @State message: string = 'Hello World' + build() { + Row() { + Column() { + Text(this.message) + .fontSize(50) + .fontWeight(FontWeight.Bold) + Button() { + Text('next page') + .fontSize(20) + .fontWeight(FontWeight.Bold) + }.type(ButtonType.Capsule) + .margin({ + top: 20 + }) + .backgroundColor('#0D9FFB') + .width('35%') + .height('5%') + .onClick(()=>{ + }) + } + .width('100%') + } + .height('100%') + } + } \ No newline at end of file diff --git a/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/TestRunner/OpenHarmonyTestRunner.ts b/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/TestRunner/OpenHarmonyTestRunner.ts new file mode 100644 index 0000000000000000000000000000000000000000..6ef52ba7e49117cebef7a7b9ff64c4c63399acfe --- /dev/null +++ b/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/TestRunner/OpenHarmonyTestRunner.ts @@ -0,0 +1,78 @@ +/* + * 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 TestRunner from '@ohos.application.testRunner' +import AbilityDelegatorRegistry from '@ohos.application.abilityDelegatorRegistry' + +var abilityDelegator = undefined +var abilityDelegatorArguments = undefined + +function translateParamsToString(parameters) { + const keySet = new Set([ + '-s class', '-s notClass', '-s suite', '-s it', + '-s level', '-s testType', '-s size', '-s timeout', + '-s dryRun' + ]) + let targetParams = ''; + for (const key in parameters) { + if (keySet.has(key)) { + targetParams = `${targetParams} ${key} ${parameters[key]}` + } + } + return targetParams.trim() +} + +async function onAbilityCreateCallback() { + console.log("onAbilityCreateCallback"); +} + +async function addAbilityMonitorCallback(err: any) { + console.info("addAbilityMonitorCallback : " + JSON.stringify(err)) +} + +export default class OpenHarmonyTestRunner implements TestRunner { + constructor() { + } + + onPrepare() { + console.info("OpenHarmonyTestRunner OnPrepare ") + } + + async onRun() { + console.log('OpenHarmonyTestRunner onRun run') + abilityDelegatorArguments = AbilityDelegatorRegistry.getArguments() + abilityDelegator = AbilityDelegatorRegistry.getAbilityDelegator() + var testAbilityName = abilityDelegatorArguments.bundleName + '.MainAbility' + let lMonitor = { + abilityName: testAbilityName, + onAbilityCreate: onAbilityCreateCallback, + }; + abilityDelegator.addAbilityMonitor(lMonitor, addAbilityMonitorCallback) + var cmd = 'aa start -d 0 -a ohos.acts.multimedia.avplayer.MainAbility' + ' -b ' + abilityDelegatorArguments.bundleName + cmd += ' '+translateParamsToString(abilityDelegatorArguments.parameters) + var debug = abilityDelegatorArguments.parameters["-D"] + if (debug == 'true') + { + cmd += ' -D' + } + console.info('cmd : '+cmd) + abilityDelegator.executeShellCommand(cmd, + (err: any, d: any) => { + console.info('executeShellCommand : err : ' + JSON.stringify(err)); + console.info('executeShellCommand : data : ' + d.stdResult); + console.info('executeShellCommand : data : ' + d.exitCode); + }) + console.info('OpenHarmonyTestRunner onRun end') + } +}; \ No newline at end of file diff --git a/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/test/AVPlayerHlsFuncTest.test.js b/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/test/AVPlayerHlsFuncTest.test.js new file mode 100644 index 0000000000000000000000000000000000000000..da04abcf20c7e784614ee764b7c8d81577cc49e3 --- /dev/null +++ b/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/test/AVPlayerHlsFuncTest.test.js @@ -0,0 +1,227 @@ +/* + * 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 media from '@ohos.multimedia.media' +import * as mediaTestBase from '../../../../../../MediaTestBaseAV'; +import * as AVPlayerTestBase from '../../../../../../AVPlayerTestBase.js'; +import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index'; + +export default function AVPlayerHlsFuncTest() { + describe('AVPlayerHlsFuncTest', function () { + const HTTP_PATH = 'http://xxx.xx.xx.xx:xxxx/'; + const PLAY_TIME = 3000; + let avPlayer = null; + let expectBitrateArray = []; + let videoSizeArray = []; + let videoSizeId = -1; + let bitrateArray = []; + let setBitrateState = ''; + let surfaceID = globalThis.value; + beforeAll(async function() { + console.info('beforeAll case'); + }) + + beforeEach(async function() { + console.info('beforeEach case'); + }) + + afterEach(async function() { + console.info('afterEach case'); + }) + + afterAll(async function() { + console.info('afterAll case'); + if (avPlayer != null) { + avPlayer.release().then(() => { + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + } + }) + + function checkArray(realArray, expectArray) { + expect(realArray.length).assertEqual(expectArray.length); + for (let i = 0; i < expectArray.length; i++) { + console.info('case expect ' + expectArray[i]); + expect(realArray[i]).assertEqual(expectArray[i]); + } + } + + async function initAVPlayer(src, done) { + let availableBitratesCnt = 0; + let bitrateDoneCnt = 0; + await media.createAVPlayer().then((video) => { + if (typeof (video) != 'undefined') { + console.info('case createAVPlayer success'); + avPlayer = video; + } else { + console.error('case createAVPlayer failed'); + expect().assertFail(); + done(); + } + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + avPlayer.on('stateChange', async (state, reason) => { + console.info(`case stateChange called, state is ${state}, reason is ${reason}`); + if (reason == media.StateChangeReason.BACKGROUND && state != AVPlayerTestBase.AV_PLAYER_STATE.COMPLETED) { + console.info(`case media.StateChangeReason.BACKGROUND`); + await avPlayer.release().then(() => { + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + } + console.info(`case state is ${state}`); + if (setBitrateState == state) { + avPlayer.setBitrate(expectBitrateArray[videoSizeId]); + } + switch (state) { + case AVPlayerTestBase.AV_PLAYER_STATE.IDLE: + break; + case AVPlayerTestBase.AV_PLAYER_STATE.INITIALIZED: + console.info(`case AVPlayerTestBase.AV_PLAYER_STATE.INITIALIZED`); + expect(avPlayer.state).assertEqual(AVPlayerTestBase.AV_PLAYER_STATE.INITIALIZED); + avPlayer.surfaceId = surfaceID; + avPlayer.prepare().then(() => { + console.info('case prepare called'); + expect(avPlayer.state).assertEqual(AVPlayerTestBase.AV_PLAYER_STATE.PREPARED); + expect(avPlayer.currentTime).assertEqual(0); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + break; + case AVPlayerTestBase.AV_PLAYER_STATE.PREPARED: + expect(avPlayer.state).assertEqual(AVPlayerTestBase.AV_PLAYER_STATE.PREPARED); + expect(avPlayer.currentTime).assertEqual(0) + avPlayer.loop = true; + avPlayer.play(); + break; + case AVPlayerTestBase.AV_PLAYER_STATE.PAUSED: + avPlayer.play(); + break; + case AVPlayerTestBase.AV_PLAYER_STATE.COMPLETED: + avPlayer.play(); + break; + case AVPlayerTestBase.AV_PLAYER_STATE.RELEASED: + expect(availableBitratesCnt).assertLarger(0); + avPlayer = null; + done(); + break; + case AVPlayerTestBase.AV_PLAYER_STATE.ERROR: + expect().assertFail(); + avPlayer.release().then(() => { + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + break; + default: + break; + } + }); + avPlayer.on('bitrateDone', (bitrate) => { + console.info(`case bitrateDone called, bitrate is ${bitrate}`); + expect(bitrate).assertEqual(expectBitrateArray[videoSizeId]); + bitrateDoneCnt++; + }); + avPlayer.on('videoSizeChange', (w, h) => { + console.info('case videoSizeChange width: ' + w + ' height: ' + h + 'videoSizeId: ' + videoSizeId); + if (w == videoSizeArray[videoSizeId][0] && h == videoSizeArray[videoSizeId][1]) { + avPlayer.release().then(() => { + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + } + }); + avPlayer.on('availableBitrates', (bitrates) => { + bitrateArray = bitrates; + checkArray(bitrateArray, expectBitrateArray); + availableBitratesCnt++; + }); + console.info(`case src is ${src}`); + avPlayer.url = src; + } + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_setBitrate_0100 + * @tc.name : 001.test hls + * @tc.desc : HLS setBitrate test + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_setBitrate_0100', 0, async function (done) { + await initAVPlayer(HTTP_PATH + '05.hls/hls_variant/index.m3u8', done); + expectBitrateArray = [165340, 344388, 387360, 765178, 1676816]; + setBitrateState = AVPlayerTestBase.AV_PLAYER_STATE.PREPARED; + videoSizeId = 1; + videoSizeArray = [ [256, 144], [426, 240], [640, 360], [854, 480], [1280, 720] ]; + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_setBitrate_0200 + * @tc.name : 001.test hls + * @tc.desc : HLS setBitrate test + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_setBitrate_0200', 0, async function (done) { + await initAVPlayer(HTTP_PATH + '05.hls/hls_variant/index.m3u8', done); + expectBitrateArray = [165340, 344388, 387360, 765178, 1676816]; + setBitrateState = AVPlayerTestBase.AV_PLAYER_STATE.PLAYING; + videoSizeId = 1; + videoSizeArray = [ [256, 144], [426, 240], [640, 360], [854, 480], [1280, 720] ]; + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_setBitrate_0300 + * @tc.name : 001.test hls + * @tc.desc : HLS setBitrate test + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_setBitrate_0300', 0, async function (done) { + await initAVPlayer(HTTP_PATH + '05.hls/hls_variant/index.m3u8', done); + expectBitrateArray = [165340, 344388, 387360, 765178, 1676816]; + setBitrateState = AVPlayerTestBase.AV_PLAYER_STATE.PAUSED; + videoSizeId = 1; + videoSizeArray = [ [256, 144], [426, 240], [640, 360], [854, 480], [1280, 720] ]; + await mediaTestBase.msleepAsync(PLAY_TIME); + avPlayer.pause(); + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_setBitrate_0400 + * @tc.name : 001.test hls + * @tc.desc : HLS setBitrate test + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_setBitrate_0400', 0, async function (done) { + await initAVPlayer(HTTP_PATH + '05.hls/hls_variant/index.m3u8', done); + expectBitrateArray = [165340, 344388, 387360, 765178, 1676816]; + setBitrateState = AVPlayerTestBase.AV_PLAYER_STATE.COMPLETED; + videoSizeId = 1; + videoSizeArray = [ [256, 144], [426, 240], [640, 360], [854, 480], [1280, 720] ]; + await mediaTestBase.msleepAsync(PLAY_TIME); + avPlayer.loop = false; + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_setBitrate_0500 + * @tc.name : 001.test hls + * @tc.desc : HLS setBitrate test + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_setBitrate_0500', 0, async function (done) { + await initAVPlayer(HTTP_PATH + '05.hls/hls_variant/index.m3u8', done); + expectBitrateArray = [165340, 344388, 387360, 765178, 1676816]; + setBitrateState = AVPlayerTestBase.AV_PLAYER_STATE.PREPARED; + videoSizeId = 3; + videoSizeArray = [ [256, 144], [426, 240], [640, 360], [854, 480], [1280, 720] ]; + }) + }); +} \ No newline at end of file diff --git a/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/test/AVPlayerHttpCompatibilityTest.test.ets b/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/test/AVPlayerHttpCompatibilityTest.test.ets new file mode 100644 index 0000000000000000000000000000000000000000..19b272a1bff5c557adff028533f1a23e6044dd58 --- /dev/null +++ b/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/test/AVPlayerHttpCompatibilityTest.test.ets @@ -0,0 +1,124 @@ +/* + * 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 {testAVPlayerFun} from '../../../../../../AVPlayerTestBase.js'; +import * as mediaTestBase from '../../../../../../MediaTestBaseAV'; +import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index'; + +export default function AVPlayerHttpCompatibilityTest() { + describe('AVPlayerHttpCompatibilityTest', function () { + const HTTP_PATH = 'http://xxx.xx.xx.xx:xxxx/'; + const VIDEO_PATH = HTTP_PATH + '01.video/'; + const AUDIO_PATH = HTTP_PATH + '02.audio/'; + const VIDEOPLAYER_PATH = HTTP_PATH + '03.videoplayer/'; + const AUDIOPLAYER_PATH = HTTP_PATH + '04.audioplayer/'; + const PLAY_TIME = 3000; + let avPlayer = null; + let avPlayTest = { + width: 0, + height: 0, + duration: -1, + } + beforeAll(async function() { + console.info('beforeAll case'); + }) + + beforeEach(async function() { + console.info('beforeEach case'); + }) + + afterEach(async function() { + console.info('afterEach case'); + }) + + afterAll(async function() { + console.info('afterAll case'); + if (avPlayer != null) { + avPlayer.release().then(() => { + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + } + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_HTTP_FORMAT_MP4_0100 + * @tc.name : 001.H264_AAC + * @tc.desc : Http playback control test + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level1 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_HTTP_FORMAT_MP4_0100', 0, async function (done) { + let path = VIDEOPLAYER_PATH + 'mp4/h264_aac_640x320_30r.mp4'; + avPlayTest = { width: 640, height: 320, duration: 10100 }; + testAVPlayerFun(path, avPlayer, avPlayTest, PLAY_TIME, done); + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_HTTP_FORMAT_MP4_0200 + * @tc.name : 002.H264_MP3 + * @tc.desc : Http playback control test + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level1 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_HTTP_FORMAT_MP4_0200', 0, async function (done) { + let path = VIDEOPLAYER_PATH + 'mp4/h264_mp3_640x480_25r.mp4'; + avPlayTest = { width: 640, height: 480, duration: 10080 }; + testAVPlayerFun(path, avPlayer, avPlayTest, PLAY_TIME, done); + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_HTTP_FORMAT_TS_0100 + * @tc.name : 001.H264_AAC + * @tc.desc : Http playback control test + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level1 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_HTTP_FORMAT_TS_0100', 0, async function (done) { + let path = VIDEOPLAYER_PATH + 'mpeg_ts/h264_aac_640x480_30r.ts'; + avPlayTest = { width: 640, height: 480, duration: 10161 }; + testAVPlayerFun(path, avPlayer, avPlayTest, PLAY_TIME, done); + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_HTTP_FORMAT_TS_0200 + * @tc.name : 002.H264_MP3 + * @tc.desc : Http playback control test + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level1 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_HTTP_FORMAT_TS_0200', 0, async function (done) { + let path = VIDEOPLAYER_PATH + 'mpeg_ts/h264_mp3_640x480_25r.ts'; + avPlayTest = { width: 640, height: 480, duration: 10169 }; + testAVPlayerFun(path, avPlayer, avPlayTest, PLAY_TIME, done); + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_HTTP_FORMAT_MKV_0100 + * @tc.name : 001.H264_AAC + * @tc.desc : Http playback control test + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level1 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_HTTP_FORMAT_MKV_0100', 0, async function (done) { + let path = VIDEO_PATH + 'H264_AAC.mkv'; + avPlayTest = { width: 720, height: 480, duration: 10057 }; + testAVPlayerFun(path, avPlayer, avPlayTest, PLAY_TIME, done); + }) + }); +} \ No newline at end of file diff --git a/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/test/AVPlayerHttpSeekTest.test.ets b/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/test/AVPlayerHttpSeekTest.test.ets new file mode 100644 index 0000000000000000000000000000000000000000..28118a875f2a2060c8b205fe0508feac44276a88 --- /dev/null +++ b/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/test/AVPlayerHttpSeekTest.test.ets @@ -0,0 +1,124 @@ +/* + * 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 {testAVPlayerSeek} from '../../../../../../AVPlayerTestBase.js'; +import * as mediaTestBase from '../../../../../../MediaTestBaseAV'; +import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index'; + +export default function AVPlayerHttpSeekTest() { + describe('AVPlayerHttpSeekTest', function () { + const HTTP_PATH = 'http://xxx.xx.xx.xx:xxxx/'; + const VIDEO_PATH = HTTP_PATH + '01.video/'; + const AUDIO_PATH = HTTP_PATH + '02.audio/'; + const VIDEOPLAYER_PATH = HTTP_PATH + '03.videoplayer/'; + const AUDIOPLAYER_PATH = HTTP_PATH + '04.audioplayer/'; + const PLAY_TIME = 3000; + let avPlayer = null; + let avPlayTest = { + width: 0, + height: 0, + duration: -1, + } + beforeAll(async function() { + console.info('beforeAll case'); + }) + + beforeEach(async function() { + console.info('beforeEach case'); + }) + + afterEach(async function() { + console.info('afterEach case'); + }) + + afterAll(async function() { + console.info('afterAll case'); + if (avPlayer != null) { + avPlayer.release().then(() => { + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + } + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_HTTP_SEEK_FORMAT_MP4_0100 + * @tc.name : 001.H264_AAC + * @tc.desc : Http playback control test + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level1 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_HTTP_SEEK_FORMAT_MP4_0100', 0, async function (done) { + let path = VIDEOPLAYER_PATH + 'mp4/h264_aac_640x320_30r.mp4'; + avPlayTest = { width: 640, height: 320, duration: 10100 }; + testAVPlayerSeek(path, avPlayer, avPlayTest, PLAY_TIME, done); + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_HTTP_SEEK_FORMAT_MP4_0200 + * @tc.name : 002.H264_MP3 + * @tc.desc : Http playback control test + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level1 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_HTTP_SEEK_FORMAT_MP4_0200', 0, async function (done) { + let path = VIDEOPLAYER_PATH + 'mp4/h264_mp3_640x480_25r.mp4'; + avPlayTest = { width: 640, height: 480, duration: 10080 }; + testAVPlayerSeek(path, avPlayer, avPlayTest, PLAY_TIME, done); + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_HTTP_SEEK_FORMAT_TS_0100 + * @tc.name : 001.H264_AAC + * @tc.desc : Http playback control test + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level1 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_HTTP_SEEK_FORMAT_TS_0100', 0, async function (done) { + let path = VIDEOPLAYER_PATH + 'mpeg_ts/h264_aac_640x480_30r.ts'; + avPlayTest = { width: 640, height: 480, duration: 10161 }; + testAVPlayerSeek(path, avPlayer, avPlayTest, PLAY_TIME, done); + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_HTTP_SEEK_FORMAT_TS_0200 + * @tc.name : 002.H264_MP3 + * @tc.desc : Http playback control test + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level1 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_HTTP_SEEK_FORMAT_TS_0200', 0, async function (done) { + let path = VIDEOPLAYER_PATH + 'mpeg_ts/h264_mp3_640x480_25r.ts'; + avPlayTest = { width: 640, height: 480, duration: 10169 }; + testAVPlayerSeek(path, avPlayer, avPlayTest, PLAY_TIME, done); + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_HTTP_SEEK_FORMAT_MKV_0100 + * @tc.name : 001.H264_AAC + * @tc.desc : Http playback control test + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level1 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_HTTP_SEEK_FORMAT_MKV_0100', 0, async function (done) { + let path = VIDEO_PATH + 'H264_AAC.mkv'; + avPlayTest = { width: 720, height: 480, duration: 10057 }; + testAVPlayerSeek(path, avPlayer, avPlayTest, PLAY_TIME, done); + }) + }); +} \ No newline at end of file diff --git a/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/test/AVPlayerLocalTest.test.js b/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/test/AVPlayerLocalTest.test.js new file mode 100644 index 0000000000000000000000000000000000000000..8bd4d3e6bbe70764c7c6c4b89cf3bad854d8be98 --- /dev/null +++ b/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/test/AVPlayerLocalTest.test.js @@ -0,0 +1,548 @@ +/* + * 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 * as mediaTestBase from '../../../../../../MediaTestBaseAV'; +import media from '@ohos.multimedia.media' +import audio from '@ohos.multimedia.audio'; +import { testAVPlayerFun, AV_PLAYER_STATE, setSource } from '../../../../../../AVPlayerTestBase.js'; +import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index'; + +export default function AVPlayerLocalTest() { + describe('AVPlayerLocalTest', function () { + const VIDEO_SOURCE = 'H264_AAC.mp4'; + const AUDIO_SOURCE = '01.mp3'; + const VIDEO_NOAUDIO = 'H264_NONE.mp4' + const PLAY_TIME = 3000; + const TAG = 'AVPlayerLocalTest:'; + let fileDescriptor = null; + let fileDescriptor2 = null; + let fileDescriptor3 = null; + let avPlayer = null; + let avPlayTest = { + width: 0, + height: 0, + duration: -1, + } + let fdPath = ''; + let fdNumber = 0; + + beforeAll(async function() { + console.info('beforeAll case'); + await mediaTestBase.getFileDescriptor(VIDEO_SOURCE).then((res) => { + fileDescriptor = res; + }); + await mediaTestBase.getFileDescriptor(AUDIO_SOURCE).then((res) => { + fileDescriptor2 = res; + }); + await mediaTestBase.getFileDescriptor(VIDEO_NOAUDIO).then((res) => { + fileDescriptor3 = res; + }); + }) + + beforeEach(async function() { + console.info('beforeEach case'); + }) + + afterEach(async function() { + if (avPlayer != null) { + avPlayer.release().then(() => { + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + } + console.info('afterEach case'); + }) + + afterAll(async function() { + console.info('afterAll case'); + await mediaTestBase.closeFileDescriptor(VIDEO_SOURCE); + await mediaTestBase.closeFileDescriptor(AUDIO_SOURCE); + await mediaTestBase.closeFileDescriptor(VIDEO_NOAUDIO); + }) + + function setAVPlayerTrackCb(avPlayer, descriptionKey, descriptionValue, done) { + let arrayDescription; + let surfaceID = globalThis.value; + avPlayer.on('stateChange', async (state, reason) => { + switch (state) { + case AV_PLAYER_STATE.INITIALIZED: + console.info(`case AV_PLAYER_STATE.INITIALIZED`); + avPlayer.surfaceId = surfaceID; + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.INITIALIZED); + avPlayer.prepare((err) => { + console.info('case prepare called' + err); + if (err != null) { + console.error(`case prepare error, errMessage is ${err.message}`); + expect().assertFail(); + done(); + } else { + console.info('case avPlayer.duration: ' + avPlayer.duration); + } + }); + break; + case AV_PLAYER_STATE.PREPARED: + await avPlayer.getTrackDescription().then((arrayList) => { + console.info('case getTrackDescription called!!'); + if (typeof (arrayList) != 'undefined') { + arrayDescription = arrayList; + } else { + console.info('case getTrackDescription is failed'); + expect().assertFail(); + } + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + expect(descriptionKey.length).assertEqual(arrayDescription.length); + for (let i = 0; i < arrayDescription.length; i++) { + mediaTestBase.checkDescription(arrayDescription[i], descriptionKey[i], descriptionValue[i]); + } + avPlayer.getTrackDescription((error, arrayList) => { + if (error == null) { + for (let i = 0; i < arrayList.length; i++) { + mediaTestBase.checkDescription(arrayList[i], descriptionKey[i], descriptionValue[i]); + } + } else { + console.info('getTrackDescription failed, message is:' + error.message); + } + avPlayer.release(); + }) + break; + case AV_PLAYER_STATE.RELEASED: + avPlayer = null; + done(); + break; + case AV_PLAYER_STATE.ERROR: + expect().assertFail(); + avPlayer.release().then(() => { + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + avPlayer = null; + break; + default: + break; + } + }) + } + + async function testCheckTrackDescription(src, avPlayer, descriptionKey, descriptionValue, done) { + console.info(`case media source: ${src}`) + media.createAVPlayer((err, video) => { + console.info(`case media err: ${err}`) + if (typeof (video) != 'undefined') { + console.info('case createAVPlayer success'); + avPlayer = video; + setAVPlayerTrackCb(avPlayer, descriptionKey, descriptionValue, done) + setSource(avPlayer, src); + } + if (err != null) { + console.error(`case createAVPlayer error, errMessage is ${err.message}`); + expect().assertFail(); + done(); + } + }); + } + + async function setAVPlayerScaleCb(avPlayer, done) { + let surfaceID = globalThis.value; + let count = 0; + avPlayer.on('stateChange', async (state, reason) => { + switch (state) { + case AV_PLAYER_STATE.INITIALIZED: + console.info(`case AV_PLAYER_STATE.INITIALIZED`); + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.INITIALIZED); + avPlayer.surfaceId = surfaceID; + avPlayer.prepare((err) => { + console.info('case prepare called' + err); + avPlayer.loop = true; + if (err != null) { + console.error(`case prepare error, errMessage is ${err.message}`); + expect().assertFail(); + done(); + } else { + console.info('case avPlayer.duration: ' + avPlayer.duration); + } + }); + break; + case AV_PLAYER_STATE.PREPARED: + console.info('case prepare called'); + avPlayer.play((err) => { + console.info('case play called' + err); + if (err != null) { + console.error(`case play error, errMessage is ${err.message}`); + expect().assertFail(); + done(); + } else { + console.info('case avPlayer.duration: ' + avPlayer.duration); + } + }); + break; + case AV_PLAYER_STATE.PLAYING: + console.info('case playing called'); + for (let i = 0; i < 20; i++) { + if (count == 0) { + console.info('case set videoScaleType : 1'); + avPlayer.videoScaleType = media.VideoScaleType.VIDEO_SCALE_TYPE_FIT_CROP; + count = 1; + } else { + console.info('case set videoScaleType : 0'); + avPlayer.videoScaleType = media.VideoScaleType.VIDEO_SCALE_TYPE_FIT; + count = 0; + } + await mediaTestBase.msleepAsync(500); + } + avPlayer.loop = false; + break; + case AV_PLAYER_STATE.COMPLETED: + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.COMPLETED); + expect(avPlayer.currentTime).assertEqual(avPlayer.duration); + avPlayer.release(); + break; + case AV_PLAYER_STATE.RELEASED: + avPlayer = null; + done(); + break; + case AV_PLAYER_STATE.ERROR: + expect().assertFail(); + avPlayer.release().then(() => { + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + avPlayer = null; + break; + default: + break; + } + }) + } + + async function testVideoScaleType(src, avPlayer, done) { + console.info(`case media source: ${src}`) + media.createAVPlayer((err, video) => { + console.info(`case media err: ${err}`) + if (typeof (video) != 'undefined') { + console.info('case createAVPlayer success'); + avPlayer = video; + setAVPlayerScaleCb(avPlayer, done) + setSource(avPlayer, src); + } + if (err != null) { + console.error(`case createAVPlayer error, errMessage is ${err.message}`); + expect().assertFail(); + done(); + } + }); + } + + async function testAudioInterruptMode(audioSource, videoSource, done) { + let testAVPlayer01 = await media.createAVPlayer(); + let testAVPlayer02 = await media.createAVPlayer(); + let surfaceID = globalThis.value; + testAVPlayer01.on('stateChange', async (state, reason) => { + switch (state) { + case AV_PLAYER_STATE.INITIALIZED: + console.info(`case AV_PLAYER_STATE.INITIALIZED`); + expect(testAVPlayer01.state).assertEqual(AV_PLAYER_STATE.INITIALIZED); + testAVPlayer01.prepare((err) => { + console.info('case prepare called' + err); + if (err != null) { + console.error(`case prepare error, errMessage is ${err.message}`); + expect().assertFail(); + done(); + } else { + console.info('case avPlayer.duration: ' + testAVPlayer01.duration); + } + }); + break; + case AV_PLAYER_STATE.PREPARED: + testAVPlayer01.audioInterruptMode = audio.InterruptMode.INDEPENDENT_MODE; + testAVPlayer01.play(); + break; + case AV_PLAYER_STATE.PLAYING: + testAVPlayer02.fdSrc = videoSource; + break; + case AV_PLAYER_STATE.RELEASED: + break; + case AV_PLAYER_STATE.ERROR: + expect().assertFail(); + testAVPlayer01.release().then(() => { + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + break; + default: + break; + } + }) + + testAVPlayer01.on('audioInterrupt', async (info) => { + console.info('case audioInterrupt1 is called, info is :' + JSON.stringify(info)); + await testAVPlayer02.release(); + await testAVPlayer01.release().then(() => { + console.info('case release called!!'); + done(); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + }); + + testAVPlayer02.on('stateChange', async (state, reason) => { + switch (state) { + case AV_PLAYER_STATE.INITIALIZED: + console.info(`case AV_PLAYER_STATE.INITIALIZED`); + expect(testAVPlayer02.state).assertEqual(AV_PLAYER_STATE.INITIALIZED); + testAVPlayer02.surfaceId = surfaceID; + testAVPlayer02.prepare((err) => { + console.info('case prepare called' + err); + if (err != null) { + console.error(`case prepare error, errMessage is ${err.message}`); + expect().assertFail(); + done(); + } else { + console.info('case avPlayer.duration: ' + testAVPlayer02.duration); + } + }); + break; + case AV_PLAYER_STATE.PREPARED: + testAVPlayer02.play(); + break; + case AV_PLAYER_STATE.PLAYING: + break; + case AV_PLAYER_STATE.RELEASED: + break; + case AV_PLAYER_STATE.ERROR: + expect().assertFail(); + testAVPlayer02.release().then(() => { + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + break; + default: + break; + } + }) + testAVPlayer01.fdSrc = audioSource; + } + + async function setOnCallback(avPlayer, done) { + let surfaceID = globalThis.value; + let count = 0; + let playCount = 0; + avPlayer.on('endOfStream', () => { + count++; + console.info(TAG + 'endOfStream success') + avPlayer.off('endOfStream') + }) + avPlayer.on('stateChange', async (state, reason) => { + switch (state) { + case AV_PLAYER_STATE.INITIALIZED: + console.info(`case AV_PLAYER_STATE.INITIALIZED`); + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.INITIALIZED); + avPlayer.surfaceId = surfaceID; + avPlayer.prepare((err) => { + console.info('case prepare called' + err); + if (err != null) { + console.error(`case prepare error, errMessage is ${err.message}`); + expect().assertFail(); + done(); + } else { + console.info('case avPlayer.duration: ' + avPlayer.duration); + } + }); + break; + case AV_PLAYER_STATE.PREPARED: + console.info('case prepare called'); + avPlayer.play().then(() => { + console.info('play called success') + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + break; + case AV_PLAYER_STATE.PLAYING: + if (playCount == 0) { + playCount++; + avPlayer.pause().then(() => { + console.info('play called success') + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + } + console.info('case playing called'); + break; + case AV_PLAYER_STATE.PAUSED: + avPlayer.play((err) => { + console.info('case play called'); + if (err != null) { + console.error(`case play error, errMessage is ${err.message}`); + expect().assertFail(); + done(); + } else { + console.info('case avPlayer.duration: ' + avPlayer.duration); + } + }); + console.info('case pause called'); + break; + case AV_PLAYER_STATE.STOPPED: + expect(count).assertEqual(1); + console.info('case stop called'); + avPlayer.release().then(() => { + console.info('play stop success') + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + break; + case AV_PLAYER_STATE.COMPLETED: + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.COMPLETED); + expect(avPlayer.currentTime).assertEqual(avPlayer.duration); + if (playCount == 1) { + playCount++ + avPlayer.play().then(() => { + console.info('play called success') + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + } else { + avPlayer.stop().then(() => { + console.info('play stop success') + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + } + break; + case AV_PLAYER_STATE.RELEASED: + avPlayer = null; + done(); + break; + case AV_PLAYER_STATE.ERROR: + expect().assertFail(); + avPlayer.release().then(() => { + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + avPlayer = null; + break; + default: + break; + } + }) + } + async function testOffCallback(src, avPlayer, done) { + console.info(`case media source: ${src}`) + media.createAVPlayer((err, video) => { + console.info(`case media err: ${err}`) + if (typeof (video) != 'undefined') { + console.info('case createAVPlayer success'); + avPlayer = video; + setOnCallback(avPlayer, done) + setSource(avPlayer, src); + } + if (err != null) { + console.error(`case createAVPlayer error, errMessage is ${err.message}`); + expect().assertFail(); + done(); + } + }); + } + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_FDSRC_0100 + * @tc.name : 001.test fdsrc + * @tc.desc : Local Video playback control test + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level0 + */ + it('SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_FDSRC_0100', 0, async function (done) { + avPlayTest = { width: 720, height: 480, duration: 10100 }; + testAVPlayerFun(fileDescriptor, avPlayer, avPlayTest, PLAY_TIME, done); + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_GETTRECKDESCRIPTION_0100 + * @tc.name : 001.test getTrackDescription + * @tc.desc : Local Video playback control test + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level1 + */ + it('SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_GETTRECKDESCRIPTION_0100', 0, async function (done) { + let videoTrackKey = new Array('bitrate', 'codec_mime', 'frame_rate', 'height', + 'track_index', 'track_type', 'width'); + let audioTrackKey = new Array('bitrate', 'channel_count', 'codec_mime', 'sample_rate', + 'track_index', 'track_type'); + let videoTrackValue = new Array(1366541, 0, 6000, 480, 0, 1, 720); + let audioTrackValue = new Array(129207, 2, 1, 44100, 1, 0); + let descriptionKey = new Array(videoTrackKey, audioTrackKey); + let descriptionValue = new Array(videoTrackValue, audioTrackValue); + testCheckTrackDescription(fileDescriptor, avPlayer, descriptionKey, descriptionValue, done) + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_GETTRECKDESCRIPTION_0200 + * @tc.name : 002.test getTrackDescription + * @tc.desc : Local Video playback control test + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level1 + */ + it('SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_GETTRECKDESCRIPTION_0200', 0, async function (done) { + let audioTrackKey = new Array('channel_count', 'codec_mime', 'sample_rate', 'track_index', + 'track_type'); + let audioTrackValue = new Array(1, 2, 48000, 0, 0); + let descriptionKey = new Array(audioTrackKey); + let descriptionValue = new Array(audioTrackValue); + testCheckTrackDescription(fileDescriptor2, avPlayer, descriptionKey, descriptionValue, done) + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_GETTRECKDESCRIPTION_0300 + * @tc.name : 003.test getTrackDescription + * @tc.desc : Local Video playback control test + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level1 + */ + it('SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_GETTRECKDESCRIPTION_0300', 0, async function (done) { + let videoTrackKey = new Array('bitrate', 'codec_mime', 'frame_rate', 'height', + 'track_index', 'track_type', 'width'); + let videoTrackValue = new Array(1506121, 0, 6000, 480, 0, 1, 720); + let descriptionKey = new Array(videoTrackKey); + let descriptionValue = new Array(videoTrackValue); + testCheckTrackDescription(fileDescriptor3, avPlayer, descriptionKey, descriptionValue, done) + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_VIDEOSCALETYPE_0100 + * @tc.name : 001.test video player videoScaleTpe + * @tc.desc : Local Video playback control test + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level1 + */ + it('SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_VIDEOSCALETYPE_0100', 0, async function (done) { + testVideoScaleType(fileDescriptor, avPlayer, done); + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_AUDIOINTERRUPTMODE_0100 + * @tc.name : 001.test audioInterruptMode Function + * @tc.desc : Local Video playback control test + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level1 + */ + it('SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_AUDIOINTERRUPTMODE_0100', 0, async function (done) { + testAudioInterruptMode(fileDescriptor2, fileDescriptor, done); + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_AUDIOINTERRUPTMODE_0200 + * @tc.name : 002.test audioInterruptMode Function + * @tc.desc : Local Video playback control test + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level1 + */ + it('SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_AUDIOINTERRUPTMODE_0200', 0, async function (done) { + testAudioInterruptMode(fileDescriptor, fileDescriptor2, done); + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_OFF_CALLBACK_0100 + * @tc.name : 001.test off callback Function + * @tc.desc : Local Video playback control test + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level1 + */ + it('SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_OFF_CALLBACK_0100', 0, async function (done) { + testOffCallback(fileDescriptor, avPlayer, done); + }) + }) +} \ No newline at end of file diff --git a/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/test/List.test.ets b/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/test/List.test.ets new file mode 100644 index 0000000000000000000000000000000000000000..7a1fff078ae9c7e84df459f641d71bdaa05f6d3d --- /dev/null +++ b/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/test/List.test.ets @@ -0,0 +1,25 @@ +/* + * 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 AVPlayerHlsFuncTest from './AVPlayerHlsFuncTest.test.js' +import AVPlayerHttpCompatibilityTest from './AVPlayerHttpCompatibilityTest.test.ets' +import AVPlayerHttpSeekTest from './AVPlayerHttpSeekTest.test.ets' +import AVPlayerLocalTest from './AVPlayerLocalTest.test.js' + +export default function testsuite() { + // AVPlayerHlsFuncTest() + // AVPlayerHttpCompatibilityTest(); + // AVPlayerHttpSeekTest(); + AVPlayerLocalTest(); +} \ No newline at end of file diff --git a/multimedia/media/media_js_standard/avPlayer/entry/src/main/module.json b/multimedia/media/media_js_standard/avPlayer/entry/src/main/module.json new file mode 100644 index 0000000000000000000000000000000000000000..cf58a5a22439b1b0886f5bcecd791ee658c608d4 --- /dev/null +++ b/multimedia/media/media_js_standard/avPlayer/entry/src/main/module.json @@ -0,0 +1,56 @@ +{ + "module": { + "name": "phone", + "type": "entry", + "srcEntrance": "./ets/Application/AbilityStage.ts", + "description": "$string:phone_entry_dsc", + "mainElement": "MainAbility", + "deviceTypes": [ + "default", + "tablet" + ], + "deliveryWithInstall": true, + "installationFree": false, + "uiSyntax": "ets", + "pages": "$profile:main_pages", + "abilities": [ + { + "name": "ohos.acts.multimedia.avplayer.MainAbility", + "srcEntrance": "./ets/MainAbility/MainAbility.ts", + "description": "$string:phone_entry_main", + "icon": "$media:icon", + "label": "$string:entry_label", + "visible": true, + "orientation": "portrait", + "skills": [ + { + "actions": [ + "action.system.home" + ], + "entities":[ + "entity.system.home" + ] + } + ] + } + ], + "requestPermissions": [ + { + "name": "ohos.permission.GRANT_SENSITIVE_PERMISSIONS", + "reason": "use ohos.permission.GRANT_SENSITIVE_PERMISSIONS" + }, + { + "name" : "ohos.permission.MEDIA_LOCATION", + "reason" : "use ohos.permission.MEDIA_LOCATION" + }, + { + "name" : "ohos.permission.READ_MEDIA", + "reason" : "use ohos.permission.READ_MEDIA" + }, + { + "name" : "ohos.permission.WRITE_MEDIA", + "reason" : "use ohos.permission.WRITE_MEDIA" + } + ] + } +} diff --git a/multimedia/media/media_js_standard/avPlayer/entry/src/main/resources/base/element/string.json b/multimedia/media/media_js_standard/avPlayer/entry/src/main/resources/base/element/string.json new file mode 100644 index 0000000000000000000000000000000000000000..2977b612ec4595b13eaaffe3e8fc578e83c42d48 --- /dev/null +++ b/multimedia/media/media_js_standard/avPlayer/entry/src/main/resources/base/element/string.json @@ -0,0 +1,32 @@ +{ + "string": [ + { + "name": "phone_entry_dsc", + "value": "i am an entry for phone" + }, + { + "name": "phone_entry_main", + "value": "the phone entry ability" + }, + { + "name": "entry_label", + "value": "ActsContextTest" + }, + { + "name": "form_description", + "value": "my form" + }, + { + "name": "serviceability_description", + "value": "my whether" + }, + { + "name": "description_application", + "value": "demo for test" + }, + { + "name": "app_name", + "value": "Demo" + } + ] +} diff --git a/multimedia/media/media_js_standard/avPlayer/entry/src/main/resources/base/media/icon.png b/multimedia/media/media_js_standard/avPlayer/entry/src/main/resources/base/media/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..474a55588fd7216113dd42073aadf254d4dba023 Binary files /dev/null and b/multimedia/media/media_js_standard/avPlayer/entry/src/main/resources/base/media/icon.png differ diff --git a/multimedia/media/media_js_standard/avPlayer/entry/src/main/resources/base/profile/main_pages.json b/multimedia/media/media_js_standard/avPlayer/entry/src/main/resources/base/profile/main_pages.json new file mode 100644 index 0000000000000000000000000000000000000000..02221db61d317863114ff0ca4dd2b33586abff12 --- /dev/null +++ b/multimedia/media/media_js_standard/avPlayer/entry/src/main/resources/base/profile/main_pages.json @@ -0,0 +1,6 @@ +{ + "src": [ + "MainAbility/pages/index/index", + "MainAbility/pages/second/second" + ] +} \ No newline at end of file diff --git a/multimedia/media/media_js_standard/avPlayer/entry/src/main/resources/rawfile/01.mp3 b/multimedia/media/media_js_standard/avPlayer/entry/src/main/resources/rawfile/01.mp3 new file mode 100644 index 0000000000000000000000000000000000000000..85573aabb4945760a979388540f9374db46a968c Binary files /dev/null and b/multimedia/media/media_js_standard/avPlayer/entry/src/main/resources/rawfile/01.mp3 differ diff --git a/multimedia/media/media_js_standard/avPlayer/entry/src/main/resources/rawfile/H264_AAC.mp4 b/multimedia/media/media_js_standard/avPlayer/entry/src/main/resources/rawfile/H264_AAC.mp4 new file mode 100644 index 0000000000000000000000000000000000000000..4b1e20e73501523f801a942f84f91ed6334161fa --- /dev/null +++ b/multimedia/media/media_js_standard/avPlayer/entry/src/main/resources/rawfile/H264_AAC.mp4 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7277b0e4910c52a8614d4f2162af3c03ad8589100f32e80dc36a9c96ba797ecd +size 1894335 diff --git a/multimedia/media/media_js_standard/avPlayer/entry/src/main/resources/rawfile/H264_NONE.mp4 b/multimedia/media/media_js_standard/avPlayer/entry/src/main/resources/rawfile/H264_NONE.mp4 new file mode 100644 index 0000000000000000000000000000000000000000..cf471bac3096e4260c871e1691ddf88eb4f2d750 --- /dev/null +++ b/multimedia/media/media_js_standard/avPlayer/entry/src/main/resources/rawfile/H264_NONE.mp4 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c1ddbd12485f5ce4edb82100caef9fa118151bc0ac291799c9339737542d0449 +size 1897169 diff --git a/multimedia/media/media_js_standard/avPlayer/signature/openharmony_sx.p7b b/multimedia/media/media_js_standard/avPlayer/signature/openharmony_sx.p7b new file mode 100644 index 0000000000000000000000000000000000000000..d2e97ce85cf501a0281d77da4dc608a7dda3b8fc Binary files /dev/null and b/multimedia/media/media_js_standard/avPlayer/signature/openharmony_sx.p7b differ