• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1/*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16import audio from '@ohos.multimedia.audio';
17import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index'
18
19const TAG = "[AudioRoutingManagerJsTest]";
20const stringParameter = 'stringParameter';
21const numberParameter = 12345678;
22
23describe("AudioRoutingManagerJsTest", function () {
24  const ERROR_INPUT_INVALID = '401';
25  const ERROR_INVALID_PARAM = '6800101';
26
27  beforeAll(async function () {
28
29    console.info(TAG + "AudioRoutingManagerJsTest:beforeAll called");
30  })
31
32  afterAll(function () {
33    console.info(TAG + 'AudioRoutingManagerJsTest:afterAll called')
34  })
35
36  beforeEach(function () {
37    console.info(TAG + 'AudioRoutingManagerJsTest:beforeEach called')
38  })
39
40  afterEach(function () {
41    console.info(TAG + 'AudioRoutingManagerJsTest:afterEach called')
42  })
43
44  function sleep(time) {
45    return new Promise((resolve) => setTimeout(resolve, time));
46  }
47
48  /*
49   * @tc.name:getPreferredOutputDeviceForRendererInfoTest001
50   * @tc.desc:Get prefer output device - promise
51   * @tc.type: FUNC
52   * @tc.require: I6C9VA
53   */
54  it("getPreferredOutputDeviceForRendererInfoTest001", 0, async function (done) {
55    let rendererInfo = {
56      content : audio.ContentType.CONTENT_TYPE_MUSIC,
57      usage : audio.StreamUsage.STREAM_USAGE_MEDIA,
58      rendererFlags : 0 }
59
60    let routingManager = audio.getAudioManager().getRoutingManager();
61    try {
62      let data = await routingManager.getPreferredOutputDeviceForRendererInfo(rendererInfo);
63      console.info(`${TAG} getPreferredOutputDeviceForRendererInfo SUCCESS`+JSON.stringify(data));
64      expect(true).assertTrue();
65      done();
66    } catch(e) {
67      console.error(`${TAG} getPreferredOutputDeviceForRendererInfo ERROR: ${e.message}`);
68      expect().assertFail();
69      done();
70    }
71  })
72
73  /*
74   * @tc.name:getPreferredOutputDeviceForRendererInfoTest002
75   * @tc.desc:Get prefer output device no parameter- promise
76   * @tc.type: FUNC
77   * @tc.require: I6C9VA
78   */
79  it("getPreferredOutputDeviceForRendererInfoTest002", 0, async function (done) {
80      let routingManager = audio.getAudioManager().getRoutingManager();
81      try {
82        let data = await routingManager.getPreferredOutputDeviceForRendererInfo();
83        console.error(`${TAG} getPreferredOutputDeviceForRendererInfo parameter check ERROR: ${JSON.stringify(data)}`);
84        expect().assertFail();
85      } catch(e) {
86        if (e.code != ERROR_INPUT_INVALID) {
87          console.error(`${TAG} getPreferredOutputDeviceForRendererInfo ERROR: ${e.message}`);
88          expect().assertFail();
89          done();
90        }
91        console.info(`${TAG} getPreferredOutputDeviceForRendererInfo check no parameter PASS`);
92        expect(true).assertTrue();
93      }
94      done();
95  })
96
97  /*
98   * @tc.name:getPreferredOutputDeviceForRendererInfoTest003
99   * @tc.desc:Get prefer output device check number parameter- promise
100   * @tc.type: FUNC
101   * @tc.require: I6C9VA
102   */
103  it("getPreferredOutputDeviceForRendererInfoTest003", 0, async function (done) {
104    let routingManager = audio.getAudioManager().getRoutingManager();
105    try {
106      let data = await routingManager.getPreferredOutputDeviceForRendererInfo(numberParameter);
107      console.error(`${TAG} getPreferredOutputDeviceForRendererInfo parameter check ERROR: `+JSON.stringify(data));
108      expect().assertFail();
109    } catch(e) {
110      if (e.code != ERROR_INPUT_INVALID) {
111        console.error(`${TAG} getPreferredOutputDeviceForRendererInfo ERROR: ${e.message}`);
112        expect().assertFail();
113        done();
114      }
115      console.info(`${TAG} getPreferredOutputDeviceForRendererInfo check number parameter PASS`);
116      expect(true).assertTrue();
117    }
118    done();
119  })
120
121  /*
122   * @tc.name:getPreferredOutputDeviceForRendererInfoTest004
123   * @tc.desc:Get prefer output device check string parameter- promise
124   * @tc.type: FUNC
125   * @tc.require: I6C9VA
126   */
127  it("getPreferredOutputDeviceForRendererInfoTest004", 0, async function (done) {
128    let routingManager = audio.getAudioManager().getRoutingManager();
129    try {
130      let data = await routingManager.getPreferredOutputDeviceForRendererInfo(stringParameter);
131      console.error(`${TAG} getPreferredOutputDeviceForRendererInfo parameter check ERROR: `+JSON.stringify(data));
132      expect().assertFail();
133    } catch(e) {
134      if (e.code != ERROR_INPUT_INVALID) {
135        console.error(`${TAG} getPreferredOutputDeviceForRendererInfo ERROR: ${e.message}`);
136        expect().assertFail();
137        done();
138      }
139      console.info(`${TAG} getPreferredOutputDeviceForRendererInfo check string parameter PASS`);
140      expect(true).assertTrue();
141    }
142    done();
143  })
144
145  /*
146   * @tc.name:getPreferredOutputDeviceForRendererInfoTest005
147   * @tc.desc:Get prefer output device - callback
148   * @tc.type: FUNC
149   * @tc.require: I6C9VA
150   */
151  it("getPreferredOutputDeviceForRendererInfoTest005", 0, async function (done) {
152    let rendererInfo = {
153      content : audio.ContentType.CONTENT_TYPE_MUSIC,
154      usage : audio.StreamUsage.STREAM_USAGE_MEDIA,
155      rendererFlags : 0 }
156
157    let routingManager = audio.getAudioManager().getRoutingManager();
158      routingManager.getPreferredOutputDeviceForRendererInfo(rendererInfo, (e, data)=>{
159        if (e) {
160          console.error(`${TAG} getPreferredOutputDeviceForRendererInfo ERROR: ${e.message}`);
161          expect(false).assertTrue();
162          done();
163        }
164        console.info(`${TAG} getPreferredOutputDeviceForRendererInfo SUCCESS`);
165        expect(true).assertTrue();
166        done();
167      });
168  })
169
170  /*
171   * @tc.name:getPreferredOutputDeviceForRendererInfoTest006
172   * @tc.desc:Get prefer output device check number parameter- callback
173   * @tc.type: FUNC
174   * @tc.require: I6C9VA
175   */
176  it("getPreferredOutputDeviceForRendererInfoTest006", 0, async function (done) {
177    let routingManager = audio.getAudioManager().getRoutingManager();
178    try {
179      routingManager.getPreferredOutputDeviceForRendererInfo(numberParameter, (e, data)=>{
180        console.info(`${TAG} getPreferredOutputDeviceForRendererInfo check number parameter ERROR`);
181        expect().assertFail();
182        done();
183      });
184    } catch (e) {
185      console.info(`${TAG} getPreferredOutputDeviceForRendererInfo check number parameter PASS, errorcode ${e.code}`);
186      expect(e.code).assertEqual(ERROR_INPUT_INVALID);
187      done();
188    }
189  })
190
191  /*
192   * @tc.name:getPreferredOutputDeviceForRendererInfoTest007
193   * @tc.desc:Get prefer output device check string parameter- callback
194   * @tc.type: FUNC
195   * @tc.require: I6C9VA
196   */
197  it("getPreferredOutputDeviceForRendererInfoTest007", 0, async function (done) {
198    let routingManager = audio.getAudioManager().getRoutingManager();
199    try {
200      routingManager.getPreferredOutputDeviceForRendererInfo(stringParameter, (e, data)=>{
201        console.error(`${TAG} getPreferredOutputDeviceForRendererInfo check string parameter ERROR`);
202        expect().assertFail();
203        done();
204      });
205    } catch (e) {
206      console.info(`${TAG} getPreferredOutputDeviceForRendererInfo check string parameter PASS, errorcode ${e.code}`);
207      expect(e.code).assertEqual(ERROR_INPUT_INVALID);
208      done();
209    }
210  })
211
212  /*
213   * @tc.name:on_referOutputDeviceForRendererInfoTest001
214   * @tc.desc:On prefer output device - callback
215   * @tc.type: FUNC
216   * @tc.require: I6C9VA
217   */
218  it("on_preferredOutputDeviceForRendererInfoTest001", 0, async function (done) {
219    let rendererInfo = {
220      content : audio.ContentType.CONTENT_TYPE_MUSIC,
221      usage : audio.StreamUsage.STREAM_USAGE_MEDIA,
222      rendererFlags : 0 }
223
224    let routingManager = audio.getAudioManager().getRoutingManager();
225    try {
226      routingManager.on('preferredOutputDeviceChangeForRendererInfo', rendererInfo, (data)=>{});
227      expect(true).assertTrue();
228      done();
229    } catch (e) {
230        console.error(`${TAG} on_referOutputDeviceForRendererInfo ERROR: ${e.message}`);
231        expect().assertFail();
232        done();
233    }
234  })
235
236  /*
237   * @tc.name:on_referOutputDeviceForRendererInfoTest002
238   * @tc.desc:On prefer output device check string parameter- callback
239   * @tc.type: FUNC
240   * @tc.require: I6C9VA
241   */
242  it("on_preferredOutputDeviceForRendererInfoTest002", 0, async function (done) {
243    let routingManager = audio.getAudioManager().getRoutingManager();
244    try {
245      routingManager.on('preferredOutputDeviceChangeForRendererInfo', stringParameter, (data)=>{});
246      console.error(`${TAG} on_referOutputDeviceForRendererInfo with string patameter ERROR: ${e.message}`);
247      expect().assertFail();
248      done();
249    } catch (e) {
250      if (e.code != ERROR_INPUT_INVALID) {
251        console.error(`${TAG} on_referOutputDeviceForRendererInfo check string parameter ERROR: ${e.message}`);
252        expect().assertFail();
253        done();
254      }
255      console.info(`${TAG} on_referOutputDeviceForRendererInfo PASS: ${e.message}`);
256      expect(true).assertTrue();
257      done();
258    }
259  })
260
261  /*
262   * @tc.name:on_referOutputDeviceForRendererInfoTest003
263   * @tc.desc:On prefer output device check number parameter- callback
264   * @tc.type: FUNC
265   * @tc.require: I6C9VA
266   */
267  it("on_preferredOutputDeviceForRendererInfoTest003", 0, async function (done) {
268    let routingManager = audio.getAudioManager().getRoutingManager();
269    try {
270      routingManager.on('preferredOutputDeviceChangeForRendererInfo', numberParameter, (data)=>{});
271      console.error(`${TAG} on_referOutputDeviceForRendererInfo with number patameter ERROR: ${e.message}`);
272      expect().assertFail();
273      done();
274    } catch (e) {
275      if (e.code != ERROR_INPUT_INVALID) {
276        console.error(`${TAG} on_referOutputDeviceForRendererInfo check number parameter ERROR: ${e.message}`);
277        expect().assertFail();
278        done();
279      }
280      console.info(`${TAG} on_referOutputDeviceForRendererInfo PASS: ${e.message}`);
281      expect(true).assertTrue();
282      done();
283    }
284  })
285
286  /*
287   * @tc.name:off_referOutputDeviceForRendererInfoTest001
288   * @tc.desc:Off prefer output device - callback
289   * @tc.type: FUNC
290   * @tc.require: I6C9VA
291   */
292  it("off_preferredOutputDeviceForRendererInfoTest001", 0, async function (done) {
293    let routingManager = audio.getAudioManager().getRoutingManager();
294    try {
295      routingManager.off('preferredOutputDeviceChangeForRendererInfo', (data)=>{});
296      console.info(`${TAG} off_referOutputDeviceForRendererInfo SUCCESS`);
297      expect(true).assertTrue();
298      done();
299    } catch (e) {
300        console.error(`${TAG} off_referOutputDeviceForRendererInfo ERROR: ${e.message}`);
301        expect().assertFail();
302        done();
303    }
304  })
305
306  /*
307   * @tc.name:getdevice001
308   * @tc.desc:getdevice - callback
309   * @tc.type: FUNC
310   * @tc.require: I6C9VA
311   */
312  it("getdevice001", 0, async function (done) {
313    let routingManager = null;
314    try {
315      routingManager = audio.getAudioManager().getRoutingManager();
316      expect(true).assertTrue();
317      done();
318    } catch (e) {
319      console.error(`${TAG} getdevice001 ERROR: ${e.message}`);
320      expect().assertFail();
321      done();
322      return;
323    }
324
325    routingManager.getDevices(audio.DeviceFlag.INPUT_DEVICES_FLAG, (err, AudioDeviceDescriptors)=>{
326      if (err) {
327        console.error(`${TAG} first getDevices ERROR: ${JSON.stringify(err)}`);
328        expect(false).assertTrue();
329        done();
330        return;
331      }
332      console.info(`${TAG} getDevices001 SUCCESS:`+ JSON.stringify(AudioDeviceDescriptors));
333      expect(AudioDeviceDescriptors.length).assertLarger(0);
334      for (let i = 0; i < AudioDeviceDescriptors.length; i++) {
335        expect(AudioDeviceDescriptors[i].displayName!==""
336        && AudioDeviceDescriptors[i].displayName!==undefined).assertTrue();
337      }
338      done();
339    })
340  });
341
342})
343