audio_player_interface.hh

Go to the documentation of this file.

/*
 * Copyright (c) 2019 SK Telecom Co., Ltd. All rights reserved.
 *
 * 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.
 */
 
#ifndef __NUGU_AUDIO_PLAYER_INTERFACE_H__
#define __NUGU_AUDIO_PLAYER_INTERFACE_H__
 
#include <capability/display_interface.hh>
#include <clientkit/capability_interface.hh>
#include <nugu.h>
 
namespace NuguCapability {
 
using namespace NuguClientKit;
 
enum class AudioPlayerState {
    IDLE, 
    PLAYING, 
    STOPPED, 
    PAUSED, 
    FINISHED 
};
 
enum class AudioPlayerEvent {
    UNDERRUN, 
    LOAD_FAILED, 
    LOAD_DONE, 
    INVALID_URL, 
    PAUSE_BY_DIRECTIVE, 
    PAUSE_BY_FOCUS, 
    PAUSE_BY_APPLICATION 
};
 
enum class RepeatType {
    NONE, 
    ONE, 
    ALL 
};
 
class NUGU_API IAudioPlayerListener : virtual public ICapabilityListener {
public:
    virtual ~IAudioPlayerListener() = default;
 
    virtual void mediaStateChanged(AudioPlayerState state, const std::string& dialog_id) = 0;
 
    virtual void mediaEventReport(AudioPlayerEvent event, const std::string& dialog_id) = 0;
 
    virtual void durationChanged(int duration) = 0;
 
    virtual void positionChanged(int position) = 0;
 
    virtual void favoriteChanged(bool favorite, const std::string& dialog_id) = 0;
 
    virtual void shuffleChanged(bool shuffle, const std::string& dialog_id) = 0;
 
    virtual void repeatChanged(RepeatType repeat, const std::string& dialog_id) = 0;
 
    virtual void requestContentCache(const std::string& key, const std::string& playurl) = 0;
 
    virtual bool requestToGetCachedContent(const std::string& key, std::string& filepath) = 0;
};
 
class NUGU_API IAudioPlayerDisplayListener : virtual public IDisplayListener {
public:
    virtual ~IAudioPlayerDisplayListener() = default;
 
    virtual bool requestLyricsPageAvailable(const std::string& id, bool& visible) = 0;
 
    virtual bool showLyrics(const std::string& id) = 0;
 
    virtual bool hideLyrics(const std::string& id) = 0;
 
    virtual void updateMetaData(const std::string& id, const std::string& json_payload) = 0;
};
 
class NUGU_API IAudioPlayerHandler : virtual public ICapabilityInterface,
                                     virtual public IDisplayHandler {
public:
    virtual ~IAudioPlayerHandler() = default;
 
    virtual std::string play() = 0;
 
    virtual std::string stop(bool direct_access = false) = 0;
 
    virtual std::string next() = 0;
 
    virtual std::string prev() = 0;
 
    virtual std::string pause(bool direct_access = false) = 0;
 
    virtual std::string resume(bool direct_access = false) = 0;
 
    virtual void seek(int msec) = 0;
 
    virtual std::string requestFavoriteCommand(bool current_favorite) = 0;
 
    virtual std::string requestRepeatCommand(RepeatType current_repeat) = 0;
 
    virtual std::string requestShuffleCommand(bool current_shuffle) = 0;
 
    virtual bool setVolume(int volume) = 0;
 
    virtual bool setMute(bool mute) = 0;
 
    virtual void addListener(IAudioPlayerListener* listener) = 0;
 
    virtual void removeListener(IAudioPlayerListener* listener) = 0;
};
 
} // NuguCapability
 
#endif /* __NUGU_AUDIO_PLAYER_INTERFACE_H__ */