1 /**
  2  * Hilo
  3  * Copyright 2015 alibaba.com
  4  * Licensed under the MIT License
  5  */
  6 
  7 /**
  8  * @class WebAudio audio playing module. It provides a better way to play and control audio, use on iOS6+ platform.
  9  * Compatibility：iOS6+、Chrome33+、Firefox28+ supported，but all Android browsers do not support.
 10  * @param {Object} properties create object properties, include all writable properties of this class.
 11  * @module hilo/media/WebAudio
 12  * @requires hilo/core/Class
 13  * @requires hilo/util/util
 14  * @requires hilo/event/EventMixin
 15  * @property {String} src The source of the playing audio.
 16  * @property {Boolean} loop Is loop playback, default value is false.
 17  * @property {Boolean} autoPlay Is the audio autoplay, default value is false.
 18  * @property {Boolean} loaded Is the audio resource loaded, readonly!
 19  * @property {Boolean} playing Is the audio playing, readonly!
 20  * @property {Number} duration The duration of the audio, readonly!
 21  * @property {Number} volume The volume of the audio, value between 0 to 1.
 22  * @property {Boolean} muted Is the audio muted, default value is false.
 23  */
 24 var WebAudio = (function(){
 25 
 26 var context = null;
 27 try {
 28     var AudioContext = window.AudioContext || window.webkitAudioContext;
 29     if (AudioContext) {
 30         context = new AudioContext();
 31     }
 32 } catch(e) {
 33     context = null;
 34 }
 35 
 36 return Class.create(/** @lends WebAudio.prototype */{
 37     Mixes: EventMixin,
 38     constructor: function(properties){
 39         util.copy(this, properties, true);
 40 
 41         this._init();
 42     },
 43 
 44     src: null,
 45     loop: false,
 46     autoPlay: false,
 47     loaded: false,
 48     playing: false,
 49     duration: 0,
 50     volume: 1,
 51     muted: false,
 52 
 53     _context: null, //WebAudio上下文 the WebAudio Context
 54     _gainNode: null, //音量控制器 the volume controller
 55     _buffer: null, //音频缓冲文件 the audio file buffer
 56     _audioNode: null, //音频播放器 the audio playing node
 57     _startTime: 0, //开始播放时间戳 the start time to play the audio
 58     _offset: 0, //播放偏移量 the offset of current playing audio
 59 
 60     /**
 61      * @private Initialize.
 62      */
 63     _init:function(){
 64         this._context = context;
 65         this._gainNode = context.createGain ? context.createGain() : context.createGainNode();
 66         this._gainNode.connect(context.destination);
 67 
 68         this._onAudioEvent = this._onAudioEvent.bind(this);
 69         this._onDecodeComplete = this._onDecodeComplete.bind(this);
 70         this._onDecodeError = this._onDecodeError.bind(this);
 71     },
 72     /**
 73      * Load audio file. Note: use XMLHttpRequest to load the audio, should pay attention to cross-origin problem.
 74      */
 75     load: function(){
 76         if(!this._buffer){
 77             var buffer = WebAudio._bufferCache[this.src];
 78             if(buffer){
 79                 this._onDecodeComplete(buffer);
 80             }
 81             else{
 82                 var request = new XMLHttpRequest();
 83                 request.src = this.src;
 84                 request.open('GET', this.src, true);
 85                 request.responseType = 'arraybuffer';
 86                 request.onload = this._onAudioEvent;
 87                 request.onprogress = this._onAudioEvent;
 88                 request.onerror = this._onAudioEvent;
 89                 request.send();
 90             }
 91             this._buffer = true;
 92         }
 93         return this;
 94     },
 95 
 96     /**
 97      * @private
 98      */
 99     _onAudioEvent: function(e){
100         // console.log('onAudioEvent:', e.type);
101         var type = e.type;
102 
103         switch(type){
104             case 'load':
105                 var request = e.target;
106                 request.onload = request.onprogress = request.onerror = null;
107                 this._context.decodeAudioData(request.response, this._onDecodeComplete, this._onDecodeError);
108                 request = null;
109                 break;
110             case 'ended':
111                 this.playing = false;
112                 this.fire('end');
113                 if(this.loop) this._doPlay();
114                 break;
115             case 'progress':
116                 this.fire(e);
117                 break;
118             case 'error':
119                 this.fire(e);
120                 break;
121         }
122     },
123 
124     /**
125      * @private
126      */
127     _onDecodeComplete: function(audioBuffer){
128         if(!WebAudio._bufferCache[this.src]){
129             WebAudio._bufferCache[this.src] = audioBuffer;
130         }
131 
132         this._buffer = audioBuffer;
133         this.loaded = true;
134         this.duration = audioBuffer.duration;
135 
136         this.fire('load');
137         if(this.autoPlay) this._doPlay();
138     },
139 
140     /**
141      * @private
142      */
143     _onDecodeError: function(){
144         this.fire('error');
145     },
146 
147     /**
148      * @private
149      */
150     _doPlay: function(){
151         this._clearAudioNode();
152 
153         var audioNode = this._context.createBufferSource();
154 
155         //some old browser are noteOn/noteOff -> start/stop
156         if(!audioNode.start){
157             audioNode.start = audioNode.noteOn;
158             audioNode.stop = audioNode.noteOff;
159         }
160 
161         audioNode.buffer = this._buffer;
162         audioNode.onended = this._onAudioEvent;
163         this._gainNode.gain.value = this.muted ? 0 : this.volume;
164         audioNode.connect(this._gainNode);
165         audioNode.start(0, this._offset);
166 
167         this._audioNode = audioNode;
168         this._startTime = this._context.currentTime;
169         this.playing = true;
170     },
171 
172     /**
173      * @private
174      */
175     _clearAudioNode: function(){
176         var audioNode = this._audioNode;
177         if(audioNode){
178             audioNode.onended = null;
179             // audioNode.disconnect(this._gainNode);
180             audioNode.disconnect(0);
181             this._audioNode = null;
182         }
183     },
184 
185     /**
186      * Play the audio. Restart playing the audio from the beginning if already playing.
187      */
188     play: function(){
189         if(this.playing) this.stop();
190 
191         if(this.loaded){
192             this._doPlay();
193         }else if(!this._buffer){
194             this.autoPlay = true;
195             this.load();
196         }
197 
198         return this;
199     },
200 
201     /**
202      * Pause (halt) playing the audio.
203      */
204     pause: function(){
205         if(this.playing){
206             this._audioNode.stop(0);
207             this._offset += this._context.currentTime - this._startTime;
208             this.playing = false;
209         }
210         return this;
211     },
212 
213     /**
214      * Continue to play the audio.
215      */
216     resume: function(){
217         if(!this.playing){
218             this._doPlay();
219         }
220         return this;
221     },
222 
223     /**
224      * Stop playing the audio.
225      */
226     stop: function(){
227         if(this.playing){
228             this._audioNode.stop(0);
229             this._audioNode.disconnect();
230             this._offset = 0;
231             this.playing = false;
232         }
233         return this;
234     },
235 
236     /**
237      * Set the volume.
238      */
239     setVolume: function(volume){
240         if(this.volume != volume){
241             this.volume = volume;
242             this._gainNode.gain.value = volume;
243         }
244         return this;
245     },
246 
247     /**
248      * Set mute mode.
249      */
250     setMute: function(muted){
251         if(this.muted != muted){
252             this.muted = muted;
253             this._gainNode.gain.value = muted ? 0 : this.volume;
254         }
255         return this;
256     },
257 
258     Statics: /** @lends WebAudio */ {
259         /**
260          * Does the browser support WebAudio.
261          */
262         isSupported: context !== null,
263 
264         /**
265          * Does browser activate WebAudio already.
266          */
267         enabled: false,
268 
269         /**
270          * Activate WebAudio. Note: Require user action events to activate. Once activated, can play audio without user action events.
271          */
272         enable: function(){
273             if(!this.enabled && context){
274                 var source = context.createBufferSource();
275                 source.buffer = context.createBuffer(1, 1, 22050);
276                 source.connect(context.destination);
277                 source.start ? source.start(0, 0, 0) : source.noteOn(0, 0, 0);
278                 this.enabled = true;
279                 return true;
280             }
281             return this.enabled;
282         },
283         /**
284          * The audio buffer caches.
285          * @private
286          * @type {Object}
287          */
288         _bufferCache:{},
289         /**
290          * Clear the audio buffer cache.
291          * @param  {String} url audio's url. if url is none, it will clear all buffer.
292          */
293         clearBufferCache:function(url){
294             if(url){
295                 this._bufferCache[url] = null;
296             }
297             else{
298                 this._bufferCache = {};
299             }
300         }
301     }
302 });
303 
304 })();