语音播放状态切换中的观察者模式

一、观察者模式的定义

在阎宏博士的《JAVA与模式》一书中开头是这样描述观察者（Observer）模式的：

　　观察者模式是对象的行为模式，又叫发布-订阅(Publish/Subscribe)模式、模型-视图(Model/View)模式、源-监听器(Source/Listener)模式或从属者(Dependents)模式。

　　观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

二、观察者模式的结构

三、观察者模式所涉及的角色有：

　　●　　抽象主题(Subject)角色：抽象主题角色把所有对观察者对象的引用保存在一个聚集（比如ArrayList对象）里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象，抽象主题角色又叫做抽象被观察者(Observable)角色。

　　●　　具体主题(ConcreteSubject)角色：将有关状态存入具体观察者对象；在具体主题的内部状态改变时，给所有登记过的观察者发出通知。具体主题角色又叫做具体被观察者(Concrete Observable)角色。

　　●　　抽象观察者(Observer)角色：为所有的具体观察者定义一个接口，在得到主题的通知时更新自己，这个接口叫做更新接口。

　　●　　具体观察者(ConcreteObserver)角色：存储与主题的状态自恰的状态。具体观察者角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态像协调。如果需要，具体观察者角色可以保持一个指向具体主题对象的引用。

四、项目案例分析

github链接（recyclerView里面语音播放状态切换）

1.观察者接口

package com.andryyu.toggle.observer;

public interface PlayAudioObserver {
    void update(int position);
}

观察者接口PlayAudioObserver定义了update()方法，用于更新语音播放状态

2.具体观察者

package com.andryyu.toggle;

import android.content.Context;
import android.support.v7.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;
import com.andryyu.toggle.observer.PlayAudioObserver;
import java.util.List;

public class PlayAudioAdapter extends RecyclerView.Adapter<PlayAudioAdapter.ViewHolder> implements PlayAudioObserver {

    private Context mContext;
    private List<AudioModel> mModelsList;
    private PlayerManager mPlayerManager;

    @Override
    public void update(int position) {
        for(int i=0;i<mModelsList.size(); i++){
            AudioModel model = mModelsList.get(i);
            if(i!=position){
                model.setStatus(false);
            }
        }
        notifyDataSetChanged();
    }

    public PlayAudioAdapter(Context context, List<AudioModel> audioModels){
        this.mContext = context;
        this.mModelsList = audioModels;
        mPlayerManager = PlayerManager.getInstance(context);
    }

    @Override
    public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.item_audio, parent, false);
        return new ViewHolder(view);
    }

    @Override
    public void onBindViewHolder(final ViewHolder holder, final int position) {
        holder.ivPlay.setTag(position);
        final AudioModel model = mModelsList.get(position);
        holder.tvName.setText(model.getName());
        holder.tvLength.setText(model.getLength());

        if(model.isStatus()){
            holder.ivPlay.setImageResource(R.mipmap.btn_voice_stop);
            holder.tvStatus.setVisibility(View.VISIBLE);
        }else{
            holder.ivPlay.setImageResource(R.mipmap.btn_voice_play);
            holder.tvStatus.setVisibility(View.INVISIBLE);
        }

        holder.ivPlay.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                boolean isStatus = model.isStatus();
                model.setStatus(!isStatus);
                mPlayerManager.playerAudio(position, new PlayerAudioListener() {
                    @Override
                    public void onStartPlay() {
                        holder.ivPlay.setImageResource(R.mipmap.btn_voice_stop);
                        holder.tvStatus.setVisibility(View.VISIBLE);
                    }

                    @Override
                    public void onComplete() {
                        holder.ivPlay.setImageResource(R.mipmap.btn_voice_play);
                        holder.tvStatus.setVisibility(View.INVISIBLE);
                        model.setStatus(false);
                    }
                });
            }
        });
    }

    @Override
    public int getItemCount() {
        return mModelsList.size();
    }
    public class ViewHolder extends RecyclerView.ViewHolder {
        private TextView tvName;
        private TextView tvLength;
        private ImageView ivPlay;
        private TextView tvStatus;

        public ViewHolder(View itemView) {
            super(itemView);
            tvName = (TextView) itemView.findViewById(R.id.tv_voice_name);
            tvLength = (TextView) itemView.findViewById(R.id.tv_voice_length);
            tvStatus = (TextView) itemView.findViewById(R.id.tv_voice_status);
            ivPlay = (ImageView) itemView.findViewById(R.id.iv_voice_play);

        }
    }
}

具体观察者类实现了观察者接口中的update()方法，对播放状态进行更新，观察者模式在被观察者和观察者之间建立一个抽象的耦合。被观察者角色所知道的只是一个具体现察者聚集，每一个具体观察者都符合一个抽象观察者的接口。被观察者并不认识任何一个具体观察者，它只知道它们都有一个共同的接口。

3.抽象主题类

package com.andryyu.toggle.observer;

public interface PlayAudioSubject {
    /**
     * 增加订阅者
     * @param observer
     */
    public void attach(PlayAudioObserver observer);

    /**
     * 删除订阅者
     * @param observer
     */
    public void detach(PlayAudioObserver observer);

    /**
     * 通知订阅者更新消息
     */
    public void notify(int position);
}

抽象主题类定义了主题接口，并声明了增添、删除、通知观察者的方法。

4.具体主题类

package com.andryyu.toggle;

import android.content.Context;
import android.media.AudioManager;
import android.media.MediaPlayer;
import com.andryyu.toggle.observer.PlayAudioObserver;
import com.andryyu.toggle.observer.PlayAudioSubject;
import java.util.ArrayList;
import java.util.List;

public class PlayerManager implements PlayAudioSubject {

    private static MediaPlayer mediaPlayer;
    private static volatile int position = -1;

    private List<PlayAudioObserver> observerList = new ArrayList<PlayAudioObserver>();
    private static PlayerManager mInstance;
    private static Context mContext;

    private PlayerManager(Context context) {
        mContext = context;
    }

    public static PlayerManager getInstance(Context context) {
        if (mInstance == null) {
            synchronized (PlayerManager.class) {
                if (mInstance == null) {
                    mInstance = new PlayerManager(context);
                }
            }
        }
        return mInstance;
    }

    public void playerAudio(int mpostion, final PlayerAudioListener audioListener){
        if (mediaPlayer != null && mediaPlayer.isPlaying()) {
            mediaPlayer.stop();
            mediaPlayer.release();
            if (position != mpostion)
                notify(mpostion);
            mediaPlayer = null;
        }

        if (position == mpostion) {
            position = -1;
            audioListener.onComplete();
            return;
        }
        ;
        position = mpostion;
        audioListener.onStartPlay();
        mediaPlayer =  MediaPlayer.create(mContext, R.raw.test11);            
        mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
            try {
                mediaPlayer.prepareAsync();
            } catch (IllegalStateException e) {
                e.printStackTrace();
            } 
        }
        mediaPlayer.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
                @Override
                public void onPrepared(MediaPlayer mp) {
                    // 装载完毕回调
                    mediaPlayer.start();
                }
        });
        mediaPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {

                @Override
                public void onCompletion(MediaPlayer mp) {
                    // 在播放完毕被回调
                    audioListener.onComplete();
                }
        });
    }

    public void stopAudio(){
        if (mediaPlayer != null && mediaPlayer.isPlaying()) {
            mediaPlayer.stop();
            mediaPlayer.release();
            mediaPlayer = null;
        }
    }

    @Override
    public void attach(PlayAudioObserver observer) {
        observerList.add(observer);
    }

    @Override
    public void detach(PlayAudioObserver observer) {
        observerList.remove(observer);
    }

    @Override
    public void notify(int position) {
        for (PlayAudioObserver observer : observerList) {
            observer.update(position);
        }
    }
}

具体主题类实现了抽象主题类中的接口方法，具体实现了对观察者的增添、删除、通知，并实现了语音播放的相关回调机制。

五、观察者模式的优缺点

优点：

1、分离了观察者和被观察者，使他们属于不同的抽象层次，从而降低了系统的耦合性，提高系统的健壮性和稳定性

2、由于分离了观察者与被观察者，当系统需要增加或删除新的模式的时候，不需要对原有的代码进行修改，而是只用添加或删除观察者，从而提高了系统的可扩展性。

3、观察者模式支持广播通讯。被观察者会向所有的登记过的观察者发出通知。

缺点：

1、如果一个被观察者对象有很多直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。

2、虽然观察者模式可以随时使观察者知道所观察的对象发生了变化，但是观察者模式没有相应的机制使观察者知道所观察的对象是怎么发生变化的。

3、如果对观察者的通知是通过另外的线程进行异步投递的话，系统必须保证投递是以自恰的方式进行的。

4、虽然观察者模式可以随时使观察者知道所观察的对象发生了变化，但是观察者模式没有相应的机制使观察者知道所观察的对象是怎么发生变化的。

语音播放状态切换中的观察者模式

二、观察者模式的结构

猜你喜欢