linphone-LinponeCore.java文件分析_java rfc2833

这个文件比较大

牢骚

这个文件真他妈大，打字打的我手都疼了。

功能：

主要功能是对linphone端的功能设置：
1. 设置Context
2. 设置全局状态
3. 添加代理配置
4. 添加Auth设置
5. 接听电话，挂断电话操作
6. 获取到当前的电话
7. 全局的遍历操作
8. 获取到Logs
9. 设置网络
10. 设置PlaybackGain
11. 静音操作
12. Dtmf操作
13. 设置获取PayloadType
14. 设置获取适配酸反
15. 设置回声抑制器等
16. 设置DSCP
17. 添加删除Friends
18. 获取ChatRoom列表
19. 设置StunServer
20. 设置FirewalPolicy
21. 设置铃声等
22. 获取设置带宽
23. 设置Ptime
24. 设置获取PreferredVedio
25. 设置获取Audio编码
26. IPV6的设置
27. 音量大小的设置
28. 加密解密的操作
29. tunnel的设置
30. 设置端口号等
31. Rfc2833

还有好多，主要是对功能的设置， 主要的功能还是在C/C++层。

UML类图–LinphoneCore用到的状态

UML类图–LinphoneCore的关键函数

LinphoneCore.java

2000多行得慢慢看啊

/*
LinphoneCore.java
Copyright (C) 2010  Belledonne Communications, Grenoble, France

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
package org.linphone.core;

import java.util.Vector;

import org.linphone.core.LinphoneCoreListener;
import org.linphone.mediastream.video.AndroidVideoWindowImpl;
import org.linphone.mediastream.video.capture.hwconf.AndroidCameraConfiguration;

import android.view.SurfaceView;

/**
 * Linphone core main object created by method {@link LinphoneCoreFactory#createLinphoneCore(LinphoneCoreListener, String, String, Object)}.
 *
 */

public interface LinphoneCore {
    /**
     * linphone core states
     */
    static public class GlobalState {

        static private Vector<GlobalState> values = new Vector<GlobalState>();
        /**
         * Off
         */
        static public GlobalState GlobalOff = new GlobalState(0,"GlobalOff");
        /**
         * Startup
         */
        static public GlobalState GlobalStartup = new GlobalState(1,"GlobalStartup");
        /**
         * On
         */
        static public GlobalState GlobalOn = new GlobalState(2,"GlobalOn");
        /**
         * Shutdown
         */
        static public GlobalState GlobalShutdown = new GlobalState(3,"GlobalShutdown");
        /**
         * Configuring
         */
        static public GlobalState GlobalConfiguring = new GlobalState(4,"GlobalConfiguring");

        private final int mValue;
        private final String mStringValue;


        private GlobalState(int value,String stringValue) {
            mValue = value;
            values.addElement(this);
            mStringValue=stringValue;
        }
        public static GlobalState fromInt(int value) {

            for (int i=0; i<values.size();i++) {
                GlobalState state = (GlobalState) values.elementAt(i);
                if (state.mValue == value) return state;
            }
            throw new RuntimeException("state not found ["+value+"]");
        }
        public String toString() {
            return mStringValue;
        }
    }
    /**
     * linphone remote provisioning states
     */
    static public class RemoteProvisioningState {

        static private Vector<RemoteProvisioningState> values = new Vector<RemoteProvisioningState>();
        /**
         * Off
         */
        static public RemoteProvisioningState ConfiguringSuccessful = new RemoteProvisioningState(0,"ConfiguringSuccessful");
        /**
         * Startup
         */
        static public RemoteProvisioningState ConfiguringFailed = new RemoteProvisioningState(1,"ConfiguringFailed");
        /**
         * On
         */
        static public RemoteProvisioningState ConfiguringSkipped = new RemoteProvisioningState(2,"ConfiguringSkipped");

        private final int mValue;
        private final String mStringValue;


        private RemoteProvisioningState(int value,String stringValue) {
            mValue = value;
            values.addElement(this);
            mStringValue=stringValue;
        }
        public static RemoteProvisioningState fromInt(int value) {

            for (int i=0; i<values.size();i++) {
                RemoteProvisioningState state = (RemoteProvisioningState) values.elementAt(i);
                if (state.mValue == value) return state;
            }
            throw new RuntimeException("state not found ["+value+"]");
        }
        public String toString() {
            return mStringValue;
        }
    }
    /**
     * Describes proxy registration states.
     *
     */
    static public class RegistrationState {

        private static Vector<RegistrationState> values = new Vector<RegistrationState>();
        /**
         * None
         */
        public static RegistrationState RegistrationNone = new RegistrationState(0,"RegistrationNone");
        /**
         * In Progress
         */
        public static RegistrationState RegistrationProgress  = new RegistrationState(1,"RegistrationProgress");
        /**
         * Ok
         */
        public static RegistrationState RegistrationOk = new RegistrationState(2,"RegistrationOk");
        /**
         * Cleared
         */
        public static RegistrationState RegistrationCleared = new RegistrationState(3,"RegistrationCleared");
        /**
         * Failed
         */
        public static RegistrationState RegistrationFailed = new RegistrationState(4,"RegistrationFailed");
        private final int mValue;
        private final String mStringValue;


        private RegistrationState(int value,String stringValue) {
            mValue = value;
            values.addElement(this);
            mStringValue=stringValue;
        }
        public static RegistrationState fromInt(int value) {

            for (int i=0; i<values.size();i++) {
                RegistrationState state = (RegistrationState) values.elementAt(i);
                if (state.mValue == value) return state;
            }
            throw new RuntimeException("state not found ["+value+"]");
        }
        public String toString() {
            return mStringValue;
        }
    }
    /**
     * Describes firewall policy.
     *
     */
    static public class FirewallPolicy {

        static private Vector<FirewallPolicy> values = new Vector<FirewallPolicy>();
        /**
         * No firewall is assumed.
         */
        static public FirewallPolicy NoFirewall = new FirewallPolicy(0,"NoFirewall");
        /**
         * Use NAT address (discouraged)
         */
        static public FirewallPolicy UseNatAddress  = new FirewallPolicy(1,"UseNatAddress");
        /**
         * Use stun server to discover RTP addresses and ports.
         */
        static public FirewallPolicy UseStun = new FirewallPolicy(2,"UseStun");
        /**
         * Use ICE.
         */
        static public FirewallPolicy UseIce = new FirewallPolicy(3,"UseIce");
        /**
         * Use uPnP.
         */
        static public FirewallPolicy UseUpnp = new FirewallPolicy(4,"UseUpnp");

        private final int mValue;
        private final String mStringValue;


        private FirewallPolicy(int value,String stringValue) {
            mValue = value;
            values.addElement(this);
            mStringValue=stringValue;
        }
        public static FirewallPolicy fromInt(int value) {

            for (int i=0; i<values.size();i++) {
                FirewallPolicy state = (FirewallPolicy) values.elementAt(i);
                if (state.mValue == value) return state;
            }
            throw new RuntimeException("state not found ["+value+"]");
        }
        public String toString() {
            return mStringValue;
        }
        public int value(){
            return mValue;
        }
    }

    /**
     * Linphone core SIP transport ports.
     * Use with {@link LinphoneCore#setSignalingTransportPorts(Transports)}
     * @ingroup initializing
     */
    static public class Transports {
        /**
         * udp port to listening on, negative value if not set
         * */
        public int udp;
        /**
         * tcp port to listening on, negative value if not set
         * */
        public int tcp;
        /**
         * tls port to listening on, negative value if not set
         * */
        public int tls;

        public Transports() {};
        public Transports(Transports t) {
            this.udp = t.udp;
            this.tcp = t.tcp;
            this.tls = t.tls;
        }
        public String toString() {
            return "udp["+udp+"] tcp["+tcp+"] tls["+tls+"]";
        }
    }
    /**
     * Stream type enum-like.
     *
     */
    static public final class StreamType {

        static private Vector<StreamType> values = new Vector<StreamType>();
        /**
         * Audio
         */
        static public final StreamType Audio = new StreamType(0, "Audio");
        /**
         * Video
         */
        static public final StreamType Video = new StreamType(1, "Video");
        /**
         * Text
         */
        static public final StreamType Text = new StreamType(2, "Text");
        /**
         * Unknown
         */
        static public final StreamType Unknown = new StreamType(3, "Unknown");
        protected final int mValue;
        private final String mStringValue;

        private StreamType(int value, String stringValue) {
            mValue = value;
            values.addElement(this);
            mStringValue = stringValue;
        }
        public static StreamType fromInt(int value) {
            for (int i = 0; i < values.size(); i++) {
                StreamType stype = (StreamType) values.elementAt(i);
                if (stype.mValue == value) return stype;
            }
            throw new RuntimeException("StreamType not found [" + value + "]");
        }
        public String toString() {
            return mStringValue;
        }
    }
    /**
     * Stream type enum-like.
     *
     */
    static public final class MediaDirection {

        static private Vector<MediaDirection> values = new Vector<MediaDirection>();
        /**
         * Invalid
         */
        static public final MediaDirection Invalid = new MediaDirection(-1, "Invalid");
        /**
         * Inactive
         */
        static public final MediaDirection Inactive = new MediaDirection(0, "Inactive");
        /**
         * SendOnly
         */
        static public final MediaDirection SendOnly = new MediaDirection(1, "SendOnly");
        /**
         * RecvOnly
         */
        static public final MediaDirection RecvOnly = new MediaDirection(2, "RecvOnly");
        /**
         * SendRecv
         */
        static public final MediaDirection SendRecv = new MediaDirection(3, "SendRecv");
        protected final int mValue;
        private final String mStringValue;

        private MediaDirection(int value, String stringValue) {
            mValue = value;
            values.addElement(this);
            mStringValue = stringValue;
        }
        public static MediaDirection fromInt(int value) {
            for (int i = 0; i < values.size(); i++) {
                MediaDirection dir = (MediaDirection) values.elementAt(i);
                if (dir.mValue == value) return dir;
            }
            throw new RuntimeException("MediaDirection not found [" + value + "]");
        }
        public String toString() {
            return mStringValue;
        }
    }
    /**
     * Media (RTP) encryption enum-like.
     *
     */
    static public final class MediaEncryption {

        static private Vector<MediaEncryption> values = new Vector<MediaEncryption>();
        /**
         * None
         */
        static public final MediaEncryption None = new MediaEncryption(0,"None");
        /**
         * SRTP
         */
        static public final MediaEncryption SRTP = new MediaEncryption(1,"SRTP");
        /**
         * ZRTP
         */
        static public final MediaEncryption ZRTP = new MediaEncryption(2,"ZRTP");
        /**
         * DTLS
         */
        static public final MediaEncryption DTLS = new MediaEncryption(3,"DTLS");
        protected final int mValue;
        private final String mStringValue;


        private MediaEncryption(int value,String stringValue) {
            mValue = value;
            values.addElement(this);
            mStringValue=stringValue;
        }
        public static MediaEncryption fromInt(int value) {

            for (int i=0; i<values.size();i++) {
                MediaEncryption menc = (MediaEncryption) values.elementAt(i);
                if (menc.mValue == value) return menc;
            }
            throw new RuntimeException("MediaEncryption not found ["+value+"]");
        }
        public String toString() {
            return mStringValue;
        }
    }
    static public final class AdaptiveRateAlgorithm {

        static private Vector<AdaptiveRateAlgorithm> values = new Vector<AdaptiveRateAlgorithm>();
        /**
         * Simple
         */
        static public final AdaptiveRateAlgorithm Simple = new AdaptiveRateAlgorithm(0,"Simple");
        /**
         * Stateful
         */
        static public final AdaptiveRateAlgorithm Stateful = new AdaptiveRateAlgorithm(1,"Stateful");
        protected final int mValue;
        private final String mStringValue;


        private AdaptiveRateAlgorithm(int value,String stringValue) {
            mValue = value;
            values.addElement(this);
            mStringValue=stringValue;
        }
        public static AdaptiveRateAlgorithm fromString(String value) {

            for (int i=0; i<values.size();i++) {
                AdaptiveRateAlgorithm alg = (AdaptiveRateAlgorithm) values.elementAt(i);
                if (alg.mStringValue.equalsIgnoreCase(value)) return alg;
            }
            throw new RuntimeException("AdaptiveRateAlgorithm not found ["+value+"]");
        }
        public String toString() {
            return mStringValue;
        }
    }
    /**
     *  EC Calibrator Status
     */
    static public class EcCalibratorStatus {

        static private Vector<EcCalibratorStatus> values = new Vector<EcCalibratorStatus>();
        /* Do not change the values of these constants or the strings associated with them to prevent breaking
           the collection of echo canceller calibration results during the wizard! */
        public static final int IN_PROGRESS_STATUS=0;
        public static final int DONE_STATUS=1;
        public static final int FAILED_STATUS=2;
        public static final int DONE_NO_ECHO_STATUS=3;
        /**
         * Calibration in progress
         */
        static public EcCalibratorStatus InProgress = new EcCalibratorStatus(IN_PROGRESS_STATUS,"InProgress");
        /**
         * Calibration done that produced an echo delay measure
         */
        static public EcCalibratorStatus Done = new EcCalibratorStatus(DONE_STATUS,"Done");
        /**
         * Calibration failed
         */
        static public EcCalibratorStatus Failed = new EcCalibratorStatus(FAILED_STATUS,"Failed");
        /**
         * Calibration done with no echo detected
         */
        static public EcCalibratorStatus DoneNoEcho = new EcCalibratorStatus(DONE_NO_ECHO_STATUS, "DoneNoEcho");

        private final int mValue;
        private final String mStringValue;


        private EcCalibratorStatus(int value,String stringValue) {
            mValue = value;
            values.addElement(this);
            mStringValue=stringValue;
        }
        public static EcCalibratorStatus fromInt(int value) {

            for (int i=0; i<values.size();i++) {
                EcCalibratorStatus status = (EcCalibratorStatus) values.elementAt(i);
                if (status.mValue == value) return status;
            }
            throw new RuntimeException("status not found ["+value+"]");
        }
        public String toString() {
            return mStringValue;
        }
        public int value(){
            return mValue;
        }
    }

    static public class UpnpState {
        static private Vector<UpnpState> values = new Vector<UpnpState>();
        /**
         * Idle
         */
        static public UpnpState Idle = new UpnpState(0, "Idle");
        /**
         * Pending
         */
        static public UpnpState Pending = new UpnpState(1, "Pending");
        /**
         * Adding
         */
        static public UpnpState Adding = new UpnpState(2, "Adding");
        /**
         * Removing
         */
        static public UpnpState Removing = new UpnpState(3, "Removing");
        /**
         * Not Available
         */
        static public UpnpState NotAvailable = new UpnpState(4, "Not available");
        /**
         * Ok
         */
        static public UpnpState Ok = new UpnpState(5, "Ok");
        /**
         * Ko
         */
        static public UpnpState Ko = new UpnpState(6, "Ko");
        /**
         * Blacklisted
         */
        static public UpnpState Blacklisted = new UpnpState(7, "Blacklisted");

        protected final int mValue;
        private final String mStringValue;

        private UpnpState(int value, String stringValue) {
            mValue = value;
            values.addElement(this);
            mStringValue = stringValue;
        }
        public static UpnpState fromInt(int value) {
            for (int i = 0; i < values.size(); i++) {
                UpnpState mstate = (UpnpState) values.elementAt(i);
                if (mstate.mValue == value) return mstate;
            }
            throw new RuntimeException("UpnpState not found [" + value + "]");
        }
        public String toString() {
            return mStringValue;
        }
    }
    /**
     * linphone log collection upload states
     */
    static public class LogCollectionUploadState {

        static private Vector<LogCollectionUploadState> values = new Vector<LogCollectionUploadState>();
        /**
         * Delivery in progress
         */
        static public LogCollectionUploadState LogCollectionUploadStateInProgress = new LogCollectionUploadState(0,"LinphoneCoreLogCollectionUploadStateInProgress");
        /**
         * Log collection upload successfully delivered and acknowledged by remote end point
         */
        static public LogCollectionUploadState LogCollectionUploadStateDelivered = new LogCollectionUploadState(1,"LinphoneCoreLogCollectionUploadStateDelivered");
        /**
         * Log collection upload was not delivered
         */
        static public LogCollectionUploadState LogCollectionUploadStateNotDelivered = new LogCollectionUploadState(2,"LinphoneCoreLogCollectionUploadStateNotDelivered");

        private final int mValue;
        private final String mStringValue;

        private LogCollectionUploadState(int value, String stringValue) {
            mValue = value;
            values.addElement(this);
            mStringValue=stringValue;
        }
        public static LogCollectionUploadState fromInt(int value) {

            for (int i=0; i<values.size();i++) {
                LogCollectionUploadState state = (LogCollectionUploadState) values.elementAt(i);
                if (state.mValue == value) return state;
            }
            throw new RuntimeException("state not found ["+value+"]");
        }
        public String toString() {
            return mStringValue;
        }
    }

    /**
     * Set the context of creation of the LinphoneCore.
     */
    public void setContext(Object context);

    /**
     * Get the LinphoneCore's global state.
    **/
    public GlobalState getGlobalState();

    /**
     * clear all added proxy configs
     */
    public void clearProxyConfigs();
    /**
     * Add a proxy configuration. This will start registration on the proxy, if registration is enabled.
     * @param proxyCfg
     * @throws LinphoneCoreException
     */
    public void addProxyConfig(LinphoneProxyConfig proxyCfg) throws LinphoneCoreException;

    /**
     * Removes a proxy configuration.
     * @param proxyCfg
     */
    public void removeProxyConfig(LinphoneProxyConfig proxyCfg);

    /**
     * Sets the default proxy.
     *<br>
     * This default proxy must be part of the list of already entered {@link LinphoneProxyConfig}.
     * Toggling it as default will make LinphoneCore favor the identity associated with the proxy configuration in all incoming and outgoing calls.
     * Better proxy configuration match may override this choice. Pass null to unset the default proxy.
     * @param proxyCfg
     */
    public void setDefaultProxyConfig(LinphoneProxyConfig proxyCfg);

    /**
     * get he default proxy configuration, that is the one used to determine the current identity.
     * @return null if no default proxy config
     */
    public LinphoneProxyConfig getDefaultProxyConfig() ;

    /**
     * Returns an array with all the auth infos stored in LinphoneCore
     */
    LinphoneAuthInfo[] getAuthInfosList();

    /**
     * Returns a matching auth info or null if no match found
     */
    LinphoneAuthInfo findAuthInfo(String username, String realm, String domain);
    /**
     * Removes a auth info.
     * @param authInfo
     */
    public void removeAuthInfo(LinphoneAuthInfo authInfo);

    /**
     * clear all the added auth info
     */
    void clearAuthInfos();
    /**
     * Adds authentication information to the LinphoneCore.
     * <br>This information will be used during all SIP transacations that require authentication.
     * @param info
     */
    void addAuthInfo(LinphoneAuthInfo info);

    /**
     * Build an address according to the current proxy config. In case destination is not a sip address, the default proxy domain is automatically appended
     * @param destination
     * @return
     * @throws If no LinphoneAddress can be built from destination
     */
    public LinphoneAddress interpretUrl(String destination) throws LinphoneCoreException;

    /**
     * Starts a call given a destination. Internally calls {@link #interpretUrl(String)} then {@link #invite(LinphoneAddress)}.
     * @param uri
     */
    public LinphoneCall invite(String destination)throws LinphoneCoreException;
    /**
     * Initiates an outgoing call given a destination LinphoneAddress
     *<br>The LinphoneAddress can be constructed directly using {@link LinphoneCoreFactory#createLinphoneAddress} , or created {@link LinphoneCore#interpretUrl(String)}. .
     * @param to the destination of the call (sip address).
     * @return linphone call
     * @throws LinphoneCoreException if linphone call cannot be created
     */
    public LinphoneCall invite(LinphoneAddress to)throws LinphoneCoreException;
    /**
     * Terminates a call.
     * @param aCall to be terminated
     */
    public void terminateCall(LinphoneCall aCall);
    /**
     * Declines an incoming call, providing a reason for declining it.
     * @param call the LinphoneCall, must be in the {@link LinphoneCall.State#IncomingReceived} state.
     * @param reason the reason for rejecting the call: {@link Reason#Declined}  or {@link Reason#Busy}
     */
    public void declineCall(LinphoneCall call, Reason reason);
    /**
     * Returns The LinphoneCall the current call if one is in call
     *
    **/
    public LinphoneCall getCurrentCall();

    /**
     * get current call remote address in case of in/out call
     * @return null if no call engaged yet
     */
    public LinphoneAddress getRemoteAddress();
    /**
     *
     * @return  true if there is a call running or pending.
     */
    public boolean isIncall();
    /**
     *
     * @return Returns true if in incoming call is pending, ie waiting for being answered or declined.
     */
    public boolean isInComingInvitePending();
    /**
     * Main loop function. It is crucial that your application call it periodically.
     *
     *  #iterate() performs various backgrounds tasks:
     * <li>receiving of SIP messages
     * <li> handles timers and timeout
     * <li> performs registration to proxies
     * <li> authentication retries The application MUST call this function from periodically, in its main loop.
     * <br> Be careful that this function must be call from the same thread as other liblinphone methods. In not the case make sure all liblinphone calls are serialized with a mutex.

     */
    public void iterate();
    /**
     * Accept an incoming call.
     *
     * Basically the application is notified of incoming calls within the
     * {@link LinphoneCoreListener#callState} listener method.
     * The application can later respond positively to the call using
     * this method.
     * @throws LinphoneCoreException
     */
    public void acceptCall(LinphoneCall aCall) throws LinphoneCoreException;

    /**
     * Accept an incoming call.
     *
     * Basically the application is notified of incoming calls within the
     * {@link LinphoneCoreListener#callState} listener method.
     * The application can later respond positively to the call using
     * this method.
     * @throws LinphoneCoreException
     */
    public void acceptCallWithParams(LinphoneCall aCall, LinphoneCallParams params) throws LinphoneCoreException;

    /**
     * Accept call modifications initiated by other end.
     *
     * Basically the application is notified of incoming calls within the
     * {@link LinphoneCoreListener#callState} listener method.
     * The application can later respond positively to the call using
     * this method.
     * @throws LinphoneCoreException
     */
    public void acceptCallUpdate(LinphoneCall aCall, LinphoneCallParams params) throws LinphoneCoreException;


    /**
     * Prevent LinphoneCore from performing an automatic answer
     *
     * Basically the application is notified of incoming calls within the
     * {@link LinphoneCoreListener#callState} listener method.
     * The application can later respond positively to the call using
     * this method.
     * @throws LinphoneCoreException
     */
    public void deferCallUpdate(LinphoneCall aCall) throws LinphoneCoreException;

    /**
     * @return a list of LinphoneCallLog
     */
    public LinphoneCallLog[] getCallLogs();

    /**
     * @return the latest outgoing call log.
     */
    public LinphoneCallLog getLastOutgoingCallLog();

    /**
     * This method is called by the application to notify the Linphone core library when network is reachable.
     * Calling this method with true trigger Linphone to initiate a registration process for all proxy
     * configuration with parameter register set to enable.
     * This method disable the automatic registration mode. It means you must call this method after each network state changes
     * @param isReachable network state
     *
     */
    public void setNetworkReachable(boolean isReachable);
    /**
     * Get network state has known by {@link LinphoneCore}
     * @return if false, there is no network connection.
     */
    public boolean isNetworkReachable();
    /**
     * destroy linphone core and free all underlying resources
     */
    public void destroy();
    /**
     * Allow to control play level before entering  sound card:
     * @param level in db
     */
    public void setPlaybackGain(float gain);
    /**
     * get play level before entering  sound card:
     * @return level in db
     */
    public float getPlaybackGain();
    /**
     * set play level
     * @param level [0..100]
     */
    public void setPlayLevel(int level);
    /**
     * get playback level [0..100];
     * -1 if not cannot be determined
     * @return
     */
    public int getPlayLevel();
    /**
     *  Mutes or unmutes the local microphone.
     * @param isMuted
     */
    void muteMic(boolean isMuted);
    /**
     *
     * @return true is mic is muted
     */
    boolean isMicMuted();

    /**
     * Initiate a dtmf signal if in call
     * @param number send dtmf ['0'..'9'] | '#', '*'
     */
    void sendDtmf(char number);
    /**
     * Initiate a dtmf signal to the speaker if not in call.
     * Sending of the DTMF is done in another function.
     * @param dtmf ['0'..'9'] | '#', '*'
     * @param duration in ms , -1 for unlimited
     */
    void playDtmf(char dtmf,int duration);
    /**
     * stop current dtmf
     */
    void stopDtmf();

    /**
     * remove all call logs
     */
    void clearCallLogs();




    /**
     * Get payload type from mime type and clock rate
     *
     * This function searches in audio and video codecs for the given payload type name and clockrate.
     * @param mime payload mime type (I.E SPEEX, PCMU, VP8)
     * @param clockRate (I.E 8000, 16000, 90000, ...)
     * @param channels  number of channels
     * @return Returns null if not found.
     */
    PayloadType findPayloadType(String mime, int clockRate, int channels);
    /***
     * get payload type  from mime type and clock rate..
     * Same as @{link {@link #findPayloadType(String, int, int)} but ignoring channels params
     * @param mime payload mime type (I.E SPEEX, PCMU, VP8)
     * @param clockRate (I.E 8000, 16000, 90000, ...)
     * @return null if not found
     */
    PayloadType findPayloadType(String mime, int clockRate);

    /***
     * get payload type  from mime type
     * Same as @{link {@link #findPayloadType(String, int, int)} but ignoring channels and clock rate params
     * @param mime payload mime type (I.E SPEEX, PCMU, VP8)
     * @return null if not found
     */
    PayloadType findPayloadType(String mime);

    /**
     * Enable payload type
     * @param pt payload type to enable, can be retrieve from {@link #findPayloadType}
     * @param enable for enable or disable the payload type
     * @exception LinphoneCoreException
     *
     */
    void enablePayloadType(PayloadType pt, boolean enable) throws LinphoneCoreException;

    /**
     * @param pt the payload type
     * @return whether or not the payload is enabled in linphonecore.
     */
    boolean isPayloadTypeEnabled(PayloadType pt);

    /**
     * @param pt the payload type
     * @return whether or not the payload epresents a VBR codec
     */
    boolean payloadTypeIsVbr(PayloadType pt);

    /**
     * Set an explicit bitrate (IP bitrate, not codec bitrate) for a given codec, in kbit/s.
     * @param pt the payload type
     * @param bitrate target IP bitrate in kbit/s
     */
    void setPayloadTypeBitrate(PayloadType pt, int bitrate);

    /**
     * Get target bitrate previously set by setPayloadTypeBitrate().
     * @param pt
     * @return IP bitrate in kbit/s
     */
    int getPayloadTypeBitrate(PayloadType pt);

    /**
     * Set an explicit bitrate (IP bitrate, not codec bitrate) for a given codec, in kbit/s.
     * @param pt the payload type
     * @param number target IP bitrate in kbit/s
     */

    /**
     * Force a number for a payload type. The LinphoneCore does payload type number assignment automatically. THis function is to be used mainly for tests, in order
     * to override the automatic assignment mechanism.
     * @param pt the payload type
     * @param number
     **/
    void setPayloadTypeNumber(PayloadType pt, int number);

    /**
     * @param pt the payload type
     * @return the payload type number assigned for this codec.
     */
    int getPayloadTypeNumber(PayloadType pt);

    /**
     * Enable adaptive rate control.
     * @param enable
     */
    void enableAdaptiveRateControl(boolean enable);

    /**
     * Enables or disable adaptive rate control.
     * @return true if adaptive rate control is enabled.
    */
    boolean isAdaptiveRateControlEnabled();

    /**
     *  Sets adaptive rate algorithm. It will be used for each new calls
     *  starting from now. Calls already started will not be updated.
     */
    void setAdaptiveRateAlgorithm(AdaptiveRateAlgorithm alg);

    /**
     * Returns which adaptive rate algorithm is currently configured for
     * future calls.
    */
    AdaptiveRateAlgorithm getAdaptiveRateAlgorithm();

    /**
     * Enables or disable echo cancellation.
     * @param enable
     */
    void enableEchoCancellation(boolean enable);
    /**
     * get EC status
     * @return true if echo cancellation is enabled.
     */
    boolean isEchoCancellationEnabled();
    /**
     * Get echo limiter status (another method of doing echo suppression, more brute force)
     * @return true if echo limiter is enabled
     */
    boolean isEchoLimiterEnabled();
    /**
     * Set transport ports linphone core will listen on
     * @param local transports ports used for signaling (TCP, UDP and TLS)
     */
    void setSignalingTransportPorts(Transports transports);
    /**Get
     * @return transports used for signaling (TCP, UDP, TLS)
     */
    Transports getSignalingTransportPorts();

    /**
     * Assign a dscp value for the SIP socket.
     * DSCP is an IP packet field used to indicate the type of routing service to routers.
     * @param dscp
     */
    void setSipDscp(int dscp);

    /**
     * Set the timeout in milliseconds for SIP transport (TCP or TLS connection establishment maximum time).
     * @param timeout_ms
    **/
    void setSipTransportTimeout(int timeout_ms);

    /**
     * Get the current SIP transport timeout.
     * @param timeout_ms
    **/
    int getSipTransportTimeout();

    /**
     * Get DSCP used for SIP socket.
     * @return the DSCP value used for the SIP socket.
     */
    int getSipDscp();

    /**
     * Activates or deactivates the speaker.
     * @param value
     */
    void enableSpeaker(boolean value);
    /**
     * Tells whether the speaker is activated.
     * @return true if speaker enabled, false otherwise
     */
    boolean isSpeakerEnabled();
    /**
     * add a friend to the current buddy list, if subscription attribute is set, a SIP SUBSCRIBE message is sent.
     * @param lf LinphoenFriend to add
     * @throws LinphoneCoreException
     */
    void addFriend(LinphoneFriend lf) throws LinphoneCoreException;

    /**
     * Adds the friend list to the linphone core.
     */
    void addFriendList(LinphoneFriendList friendList) throws LinphoneCoreException;

    /**
     * Removes the friend list from the linphone core.
     */
    void removeFriendList(LinphoneFriendList friendList) throws LinphoneCoreException;

    /**
     * Creates a friend list.
     */
    LinphoneFriendList createLinphoneFriendList() throws LinphoneCoreException;

    /**
     * Get list of LinphoneFriend
     * @return LinphoneFriend list
     */
    LinphoneFriend[] getFriendList();

    /**
     * Get list of LinphoneFriendList
     * @return LinphoneFriendList list
     */
    LinphoneFriendList[] getFriendLists();

    /**
     * @brief Set my presence status
     * @param minutes_away how long in away
     * @param alternative_contact sip uri used to redirect call in state LinphoneStatusMoved
     * @param status OnlineStatus
     * @deprecated Use setPresenceModel() instead
     */
    void setPresenceInfo(int minutes_away, String alternative_contact, OnlineStatus status);
    /**
     * @brief Get my presence status
     * @return OnlineStatus
     * @deprecated Use getPresenceModel() instead
     */
    OnlineStatus getPresenceInfo();
    /**
     * @brief Set my presence status
     * @param presence #LinphonePresenceModel
     */
    void setPresenceModel(PresenceModel presence);
    /**
     * @brief Get my presence status
     * @return A #PresenceModel object, or null if no presence model has been set.
     */
    PresenceModel getPresenceModel();
    /**
     * Create a new chat room for messaging from a sip uri like sip:joe@sip.linphone.org
     * @param to    destination address for messages
     *
     * @return {@link LinphoneChatRoom} where messaging can take place.
     */
    LinphoneChatRoom getOrCreateChatRoom(String to);
    /**
     * Create a new chat room for messaging from a linphone address
     * @param to    destination address for messages
     *
     * @return {@link LinphoneChatRoom} where messaging can take place.
     */
    LinphoneChatRoom getChatRoom(LinphoneAddress to);
    /**
     * Set the native video window id where the video is to be displayed.
     * On Android, it must be of type {@link AndroidVideoWindowImpl}
     * @param video window of type {@link AndroidVideoWindowImpl}
    **/
    void setVideoWindow(Object w);
    /**
     * Set the native video window id where the video preview is to be displayed.
     * On Android, it must of type {@link SurfaceView}
     * @param video window of type {@link SurfaceView}
    **/
    void setPreviewWindow(Object w);
    /**
     * Tells the core the device current orientation. This can be used by capture filters
     * on mobile devices to select between portrait/landscape mode and to produce properly
     * oriented images. The exact meaning of the value in rotation if left to each device
     * specific implementations.
     *@param rotation . Android supported values are 0, 90, 180 and 270.
     *
    **/
    void setDeviceRotation(int rotation);
    /**
     * Sets the active video device.
     *
     * @param id  of the video device as returned by {@link AndroidCameraConfiguration#retrieveCameras}
    **/
    void setVideoDevice(int id);
    /**
     * Returns the id of the currently active video device as found in {@link AndroidCameraConfiguration#retrieveCameras}.
    **/
    int getVideoDevice();


    /**
     * Teturns true if the underlying sdk support video
     *
     * */
    boolean isVideoSupported();

    /**
     * Enables video globally.
     *
     *
     * This function does not have any effect during calls. It just indicates #LinphoneCore to
     * initiate future calls with video or not. The two boolean parameters indicate in which
     * direction video is enabled. Setting both to false disables video entirely.
     *
     * @param vcap_enabled indicates whether video capture is enabled
     * @param display_enabled indicates whether video display should be shown
     *
    **/
    void enableVideo(boolean vcap_enabled, boolean display_enabled);
    /**
     * Returns TRUE if video is enabled, FALSE otherwise.
     *
     ***/
    boolean isVideoEnabled();

    /**
     * Specify a STUN server to help firewall traversal.
     * @param stun_server Stun server address and port, such as stun.linphone.org or stun.linphone.org:3478
     */
    void setStunServer(String stun_server);
    /**
     * Get STUN server
     * @return stun server address if previously set.
     */
    String getStunServer();

    /**
     * Sets policy regarding workarounding NATs
     * @param pol one of the FirewallPolicy members.
    **/
    void setFirewallPolicy(FirewallPolicy pol);
    /**
     * @return previously set firewall policy.
     */
    FirewallPolicy getFirewallPolicy();
    /**
     * Initiates an outgoing call given a destination LinphoneAddress
     *
     * @param addr the destination of the call {@link #LinphoneAddress }.
     * @param params call parameters {@link #LinphoneCallParams }
     *
     *<br>The LinphoneAddress can be constructed directly using {@link LinphoneCoreFactory#createLinphoneAddress} , or created {@link LinphoneCore#interpretUrl(String)}. .
     *
     * @return a {@link #LinphoneCall LinphoneCall} object
     * @throws LinphoneCoreException  in case of failure
    **/
    LinphoneCall inviteAddressWithParams(LinphoneAddress destination, LinphoneCallParams params) throws LinphoneCoreException ;
    /**
     * Updates a running call according to supplied call parameters or parameters changed in the LinphoneCore.
     *
     * In this version this is limited to the following use cases:
     * - setting up/down the video stream according to the video parameter of the {@link LinphoneCallParams} (see {@link LinphoneCallParams#enableVideo} ).
     * - changing the size of the transmitted video after calling {@link LinphoneCore#setPreferredVideoSize(VideoSize)}
     *
     * In case no changes are requested through the {@link LinphoneCallParams} argument, then this argument can be omitted and set to null.
     * @param call the {@link LinphoneCall} to be updated
     * @param params the new  {@link  LinphoneCallParams call parameters} to use. (may be NULL)
     * @return 0 if successful, -1 otherwise.
    **/
    int updateCall(LinphoneCall call, LinphoneCallParams params);

    /**
     * Create a LinphoneCallParams suitable to be used for a new incoming call or an established call, in
     * methods LinphoneCore.inviteAddressWithParams(), LinphoneCore.updateCall(), LinphoneCore.acceptCallWithParams(), LinphoneCore.acceptCallUpdate().
     * The call parameter is optional: when creating a LinphoneCallParams for an outgoing call that is about to be created, 
     * it shall be set to null.
     * @param call (optional)
     * @return a LinphoneCallParams object, representing the call settings guessed from the current LinphoneCore and compatible with the call object if any.
     */
    LinphoneCallParams createCallParams(LinphoneCall call);

    /**
     * Sets the path to a wav file used for ringing.
     *
     * @param path The file must be a wav 16bit linear. Local ring is disabled if null
     */
    void setRing(String path);
    /**
     * gets the path to a wav file used for ringing.
     *
     * @return null if not set
     */
    String getRing();

    /**
     * Sets file or folder containing trusted root CAs
     *
     * @param path path to file with multiple PEM certif or to folder with multiple PEM files
     */
    void setRootCA(String path);

    /**
     * Sets the path to a wav file used for for ringing back.
     *
     * Ringback means the ring that is heard when it's ringing at the remote party.
     *
     * @param path The file must be a wav 16bit linear.
     */
    void setRingback(String path);

    /**
     * Retrieve the maximum available upload bandwidth.
    **/
    int getUploadBandwidth();

    void setUploadBandwidth(int bw);

    /**
     * Retrieve the maximum available download bandwidth.
    **/
    int getDownloadBandwidth();

    /**
     * Sets maximum available download bandwidth
     *
     *
     * This is IP bandwidth, in kbit/s.
     * This information is used signaled to other parties during
     * calls (within SDP messages) so that the remote end can have
     * sufficient knowledge to properly configure its audio & video
     * codec output bitrate to not overflow available bandwidth.
     *
     * @param bw the bandwidth in kbits/s, 0 for infinite
     */
    void setDownloadBandwidth(int bw);

    /**
     * Sets audio packetization interval suggested for remote end.
     * @param ptime packetization interval in milliseconds
     */
    void setDownloadPtime(int ptime);

    /**
     * Sets audio packetization interval sent to remote end.
     * @param ptime packetization interval in milliseconds
     */
    void setUploadPtime(int ptime);
    /**
     * Sets the preferred video size.
     *
     * This applies only to the stream that is captured and sent to the remote party,
     * since we accept all standard video size on the receive path.
     * @param vSize
     *
    **/
    void setPreferredVideoSize(VideoSize vSize);
    /**
     * Sets the preferred video size giving a known size name.
     *
     * This applies only to the stream that is captured and sent to the remote party,
     * since we accept all standard video size on the receive path.
     * @param name A known video name (eg. vga or 720p)
    **/
    void setPreferredVideoSizeByName(String name);
    /**
     * get current preferred video size for sending.
     * @return  video size
     *
    **/
    VideoSize getPreferredVideoSize();

    /**
     * Set the preferred frame rate for video.
     * Based on the available bandwidth constraints and network conditions, the video encoder
     * remains free to lower the framerate. There is no warranty that the preferred frame rate be the actual framerate.
     * used during a call. Default value is 0, which means "use encoder's default fps value".
     * @param fps the target frame rate in number of frames per seconds.
    **/
    void setPreferredFramerate(float fps);

    /**
     * Returns the preferred video framerate, previously set by setPreferredFramerate().
     * @return frame rate in number of frames per seconds.
    **/
    float getPreferredFramerate();
    /**
     * Returns the currently supported audio codecs, as PayloadType elements
     * @return
     */
    PayloadType[] getAudioCodecs();
    /**
     * Set the list of audio codecs.
     * @param codecs List of PayloadType objects
     */
    void setAudioCodecs(PayloadType[] codecs);
    /**
     * Returns the currently supported video codecs, as PayloadType elements
     * @return
     */
    PayloadType[] getVideoCodecs();
    /**
     * Set the list of video codecs.
     * @param codecs List of PayloadType objects
     */
    void setVideoCodecs(PayloadType[] codecs);
    /**
     * enable signaling keep alive. small udp packet sent periodically to keep udp NAT association
     */
    void enableKeepAlive(boolean enable);
    /**
     * get keep elive mode
     * @return true if enable
     */
    boolean isKeepAliveEnabled();
    /**
     * Start an echo calibration of the sound devices, in order to find adequate settings for the echo canceler automatically.
     * status is notified to {@link LinphoneCoreListener#ecCalibrationStatus(EcCalibratorStatus, int, Object)}
     * @param listener the LinphoneEchoCalibrationListener to call when the calibration is done
     * @throws LinphoneCoreException if operation is still in progress;
    **/
    void startEchoCalibration(LinphoneCoreListener listener) throws LinphoneCoreException;

    /**
     * Returns true if echo calibration is recommended.
     * If the device has a builtin echo canceller or calibration value is already known, it will return false.
     */
    boolean needsEchoCalibration();

    /**
     * Returns true if the software echo canceler needs to be turned on.
     * If the device has a builtin echo canceller, it will return false.
     */
    boolean hasBuiltInEchoCanceler();

    void enableIpv6(boolean enable);

    boolean isIpv6Enabled();

    /**
     * @deprecated
     * @param i
     */
    void adjustSoftwareVolume(int i);

    /**
     * Pauses a call. If a music file has been setup using {@link LinphoneCore#setPlayFile(String)},
     * this file will be played to the remote user.
     *
    **/
    boolean pauseCall(LinphoneCall call);
    /**
     * Resume a call.
    **/
    boolean resumeCall(LinphoneCall call);
    /**
     * Pause all currently running calls.
    **/
    boolean pauseAllCalls();

    void setZrtpSecretsCache(String file);
    void enableEchoLimiter(boolean val);

    /**
     * Create a conference
     * @param params Parameters of the conference. Can be null
     * @return The new conference or null if the creation has failed
     */
    LinphoneConference createConference(LinphoneConferenceParams params);
    /**
     * Return the value of the C pointer on the conference instance.
     *
     * That function can be used to test whether a conference is running.
     * @return A positive value if a conference is running, 0 if not.
     **/
    LinphoneConference getConference();
    /**
     * Indicates whether the local user is part of the conference.
    **/
    boolean isInConference();
    /**
     * Moves the local participant inside the conference.
     *
     * Makes the local participant to join the conference.
     * Typically, the local participant is by default always part of the conference when joining an active call into a conference.
     * However, by calling {@link #leaveConference()} and {@link #enterConference()} the application can decide to temporarily
     * move out and in the local participant from the conference.
     *
     * @returns true if successful
    **/
    boolean enterConference();
    /**
     * Moves the local participant out of the conference.
     * When the local participant is out of the conference, the remote participants can continue to talk normally.
    **/
    void leaveConference();
    /**
     * Merge a call into a conference.
     *
     * If this is the first call that enters the conference, the virtual conference will be created automatically.
     * If the local user was actively part of the call (ie not in paused state), then the local user is automatically entered into the conference.
     * If the call was in paused state, then it is automatically resumed when entering into the conference.
     * @param call an established call, either in {@link LinphoneCall.State#StreamsRunning} or {@link LinphoneCall.State#Paused} state.
     *
    **/
    void addToConference(LinphoneCall call);
    /**
     * Remove a call from the conference.
     * @param call a call that has been previously merged into the conference.
     *
     * After removing the remote participant belonging to the supplied call, the call becomes a normal call in paused state.
     * If one single remote participant is left alone together with the local user in the conference after the removal, then the conference is
     * automatically transformed into a simple call in StreamsRunning state.
     * The conference's resources are then automatically destroyed.
     *
     * In other words, unless {@link #leaveConference()} is explicitely called, the last remote participant of a conference is automatically
     * put in a simple call in running state.
     *
     **/
    void removeFromConference(LinphoneCall call);
    /**
     * Add all calls into a conference.
     *
     * Merge all established calls (either in {@link LinphoneCall.State#StreamsRunning} or {@link LinphoneCall.State#Paused}) into a conference.
     *
    **/
    void addAllToConference();

    /**
     * Terminates the conference and the calls associated with it.
     *
     * All the calls that were merged to the conference are terminated, and the conference resources are destroyed.
     *
    **/
    void terminateConference();
    /**
     * Returns the number of participants to the conference, including the local participant.
     *
     * Typically, after merging two calls into the conference, there is total of 3 participants:
     * the local participant (or local user), and two remote participants that were the destinations of the two previously establised calls.
     *
     * @returns the number of participants to the conference
    **/
    int getConferenceSize();

    /**
     * Request recording of the conference into a supplied file path.
     * The format is wav.
     * @param path where to write recording file
    **/
    void startConferenceRecording(String path);

    /**
     * Stop recording of the conference.
    **/
    void stopConferenceRecording();
    /**
     * Terminates all the calls.
     */
    void terminateAllCalls();
    /**
     * Returns all calls.
     * @return an array with all call currently handle by Linphone core
    **/
    LinphoneCall[] getCalls();
    /**
     * Get number of calls currently handled by Linphone core
     * @returns number of calls
     * */
    int getCallsNb();

    /**
     * Performs a simple call transfer to the specified destination.
     *
     * @param call The current local call remains active and thus can be later paused or terminated.
     * @param  referTo The remote call party endpoint is expected to issue a new call to this specified destination.
    **/
    void transferCall(LinphoneCall call, String referTo);
    /**
     * Transfer a call to destination of another running call. This is used for "attended transfer" scenarios.
     * The transfered call is supposed to be in paused state, so that it is able to accept the transfer immediately.
     * The destination call is a call previously established to introduce the transfered person.
     * This method will send a transfer request to the transfered person. The phone of the transfered is then
     * expected to automatically call to the destination of the transfer. The receiver of the transfer will then automatically
     * close the call with us (the 'dest' call).
     * @param call a running call you want to transfer
     * @param dest a running call whose remote person will receive the transfer
    **/
    void transferCallToAnother(LinphoneCall callToTransfer, LinphoneCall destination);

    /**
     * Start a new call as a consequence of a transfer request received from a call.
     * This function is for advanced usage: the execution of transfers is automatically managed by the LinphoneCore. However if an application
     * wants to have control over the call parameters for the new call, it should call this function immediately during the LinphoneCallRefered notification.
     * @param call a call that has just been notified about LinphoneCallRefered state event.
     * @param params the call parameters to be applied to the new call.
     * @return a LinphoneCall corresponding to the new call that is attempted to the transfer destination.
    **/
    LinphoneCall startReferedCall(LinphoneCall call, LinphoneCallParams params);
    /**
     * Search from the list of current calls if a remote address match uri
     * @param uri which should match call remote uri
     * @return LinphoneCall or NULL is no match is found
     */
    LinphoneCall findCallFromUri(String uri);
    /**
     * Get the maximum number of simultaneous calls Linphone core can manage at a time. All new call above this limit are declined with a busy answer
     * @return max number of simultaneous calls
     */
    int getMaxCalls();
    /**
     * Set the maximum number of simultaneous calls Linphone core can manage at a time. All new call above this limit are declined with a busy answer
     * @param max number of simultaneous calls
     */
    void setMaxCalls(int max);
    /**
     * @deprecated
     * @param uri
     * @return
     */
    boolean isMyself(String uri);

    /**
     * Use this method to check the calls state and forbid proposing actions
     * which could result in an active call.
     * Eg: don't start a new call if one is in outgoing ringing.
     * Eg: don't merge to conference either as it could result
     *     in two active calls (conference and accepted call).
     * @return
     */
    boolean soundResourcesLocked();
    /**
     * Returns whether given media encryption is supported by liblinphone.
     */
    boolean mediaEncryptionSupported(MediaEncryption menc);
    /**
     * set media encryption (rtp) to use
     * @params menc: MediaEncryption.None, MediaEncryption.SRTP or MediaEncryption.ZRTP
     */
    void setMediaEncryption(MediaEncryption menc);
    /**
     * return selected media encryption
     * @return MediaEncryption.None, MediaEncryption.SRTP or MediaEncryption.ZRTP
     */
    MediaEncryption getMediaEncryption();
/**
     * Set media encryption required for outgoing calls
     */
    void setMediaEncryptionMandatory(boolean yesno);
    /**
     * @return if media encryption is required for outgoing calls
     */
    boolean isMediaEncryptionMandatory();

    /**
     * @param path path to music file played to remote side when on hold.
     */
    void setPlayFile(String path);


    enum TunnelMode {
        disable(0),
        enable(1),
        auto(2);
        private final int value;

        private TunnelMode(int value){
            this.value = value;
        }
        public static int enumToInt(TunnelMode enum_mode) {
            return enum_mode.value;
        }
        public static TunnelMode intToEnum(int value) {
            switch(value) {
            case 0: return disable;
            case 1: return enable;
            case 2: return auto;
            default: return disable;
            }
        }
    }

    /**
     * @deprecated Use tunnelSetMode() instead
     * Enable or disable tunnel
     * @param enable True to enable and false to disable
     */
    void tunnelEnable(boolean enable);

    /**
     * Set the tunnel mode.
     * The tunnel can be enable or disable by passing 'enable' or 'disable'.
     * If the mode is set to 'auto', Linphone will try to establish an RTP session
     * on the mirror port of the tunnel server. If the connection fails, the tunnel
     * will be activated. 
     * @param mode enable, disable or auto
     */
    void tunnelSetMode(TunnelMode mode);

    /**
     * Get the set mode
     * @return 
     */
    TunnelMode tunnelGetMode();

    /**
     * Set whether sip packets must pass through the tunnel
     * @param enable If true, tunnel will transport SIP packets in addition
     * of RTP packets.
     */
    void tunnelEnableSip(boolean enable);

    /**
     * Check whether SIP tuneling is enabled
     * @return true means the tunnel is set to transport SIP packets
     */
    boolean tunnelSipEnabled();

    /**
     * @deprecated Use tunnelSetMode instaead
     * Enable tunnel if the mirror RTP session cannot be established
     */
    void tunnelAutoDetect();

    /**
     * Clean the list of server
     */
    void tunnelCleanServers();

    /**
     * Set an optional HTTP proxy
     * @param proxy_host
     * @param port 
     * @param username 
     * @param password
     */
    void tunnelSetHttpProxy(String proxy_host, int port, String username, String password);
    /**
     * @param host tunnel server ip address
     * @param port tunnel server tls port, recommended value is 443
     * @param udpMirrorPort remote port on the tunnel server side  used to test udp reachability
     * @param roundTripDelay udp packet round trip delay in ms considered as acceptable. recommended value is 1000 ms
     */
    void tunnelAddServerAndMirror(String host, int port, int udpMirrorPort, int roundTripDelay);
    /**
     * Add a server to the list of tunnel servers.
     * @param config Parameters of the server to add.
     */
    void tunnelAddServer(TunnelConfig config);
    /**
     * Returns a list of configured servers.
     * @return Array of server configs.
     */
    TunnelConfig[] tunnelGetServers();

    boolean isTunnelAvailable();
    /**
     * Returns an unmodifiable list of entered proxy configurations.
     * @return list of proxy config
    **/
    LinphoneProxyConfig[] getProxyConfigList();
    /**
     * Sets the default policy for video.
     * This policy defines whether:
     * @param autoInitiate video shall be initiated by default for outgoing calls
     * @param autoAccept video shall be accepter by default for incoming calls
    **/
    void setVideoPolicy(boolean autoInitiate, boolean autoAccept);

    /**
     * Gets the policy for the autoInitiate video
     */
    boolean getVideoAutoInitiatePolicy();

    /**
     * Gets the policy for the autoAccept video
     */
    boolean getVideoAutoAcceptPolicy();

    /** Set static picture to be used when "Static picture" is the video device
     * @param path to the static picture file
     * */
    void setStaticPicture(String path);
    /**
     * Sets the user agent string used in SIP messages.
     * @param user agent name
     * @param user agent version
    **/
    void setUserAgent(String name, String version);
    /**
     * Set the number of cores used for media processing
     * */
    void setCpuCount(int count);

    /**
     * remove a call log
     */
    public void removeCallLog(LinphoneCallLog log);

    /**
     * @return count of missed calls
     */
    public int getMissedCallsCount();

    /**
     * Set missed calls count to zero
     */
    public void resetMissedCallsCount();
    /**
     * re-initiates registration if network is up.
     */
    public void refreshRegisters();

    /**
     * return the version code of linphone core
     */
    public String getVersion();

    /**
     * remove a linphone friend from linphone core and linphonerc
     */
    void removeFriend(LinphoneFriend lf);

    /**
     * return a linphone friend (if exists) that matches the sip address
     */
    LinphoneFriend findFriendByAddress(String sipUri);

    /**
     * Sets the UDP port used for audio streaming.
    **/
    void setAudioPort(int port);

    /**
     * Sets the UDP port range from which to randomly select the port used for audio streaming.
     */
    void setAudioPortRange(int minPort, int maxPort);

    /**
     * Assign a DSCP value to the audio RTP sockets.
     * @param dscp the DSCP value.
     * DSCP is an IP header field used to indicate a type of service to routers.
     */
    void setAudioDscp(int dscp);

    /**
     * Return DSCP value used for the audio RTP sockets.
     * @return the DSCP value used for the audio RTP sockets.
     */
    int getAudioDscp();

    /**
     * Sets the UDP port used for video streaming.
    **/
    void setVideoPort(int port);

    /**
     * Sets the UDP port range from which to randomly select the port used for video streaming.
     */
    void setVideoPortRange(int minPort, int maxPort);

    /**
     * Assign a DSCP value to the video RTP sockets.
     * @param dscp the DSCP value.
     * DSCP is an IP header field used to indicate a type of service to routers.
     */
    void setVideoDscp(int dscp);

    /**
     * Return DSCP value used for the video RTP sockets.
     * @return the DSCP value used for the video RTP sockets.
     */
    int getVideoDscp();

    /**
     * Set the incoming call timeout in seconds.
     * If an incoming call isn't answered for this timeout period, it is
     * automatically declined.
    **/
    void setIncomingTimeout(int timeout);

    /**
     * Set the call timeout in seconds.
     * Once this time is elapsed (ringing included), the call is automatically hung up.
    **/
    void setInCallTimeout(int timeout);
    /**
     * Allow to control microphone level:
     * @param gain in db
    **/
    void setMicrophoneGain(float gain);

    /**
     * Set address to use if no LinphoneProxyConfig configured
     */
    void setPrimaryContact(String address);

    /**
     * Returns the address used if no LinphoneProxyConfig configured
     */
    String getPrimaryContact();

    /**
     * Set username and display name to use if no LinphoneProxyConfig configured
     */
    void setPrimaryContact(String displayName, String username);

    /**
     * Returns the username used if no LinphoneProxyConfig configured
     */
    String getPrimaryContactUsername();

    /**
     * Returns the display name used if no LinphoneProxyConfig configured
     */
    String getPrimaryContactDisplayName();

    /**
     * Enable/Disable the use of SIP INFO for DTMFs
     */
    void setUseSipInfoForDtmfs(boolean use);

    /**
     * Returns the state of use of SIP INFO for DTMFs
     */
    boolean getUseSipInfoForDtmfs();

    /**
     * Enable/Disable the use of inband DTMFs
     */
    void setUseRfc2833ForDtmfs(boolean use);

    /**
     * Returns the state of use of inband DTMFs
     */
    boolean getUseRfc2833ForDtmfs();

    /**
     * @return returns LpConfig object to read/write to the config file: usefull if you wish to extend
     * the config file with your own sections
     */
    LpConfig getConfig();


    /**
     * Return the availability of uPnP.
     *
     * @return true if uPnP is available otherwise return false.
     */
    public boolean upnpAvailable();

    /**
     * Return the internal state of uPnP.
     *
     * @return an UpnpState.
     */
    public UpnpState getUpnpState();

    /**
     * Return the external ip address of router.
     * In some cases the uPnP can have an external ip address but not a usable uPnP
     * (state different of Ok).
     *
     * @return a null terminated string containing the external ip address. If the
     * the external ip address is not available return null.
     */
    public String getUpnpExternalIpaddress();

    /**
     * Create an empty INFO message.
     * It can later be sent using {@link LinphoneCall.sendInfoMessage() }.
     * @return the new info message.
     */
    public LinphoneInfoMessage createInfoMessage();

    /**
     * Sends an outgoing subscription for a resource with given event, expiration period, and content.
     * The state changes of the new subscriptions can be followed thanks to { @link LinphoneCoreListener.subscriptionStateChanged() } and
     * { @link LinphoneCoreListener.notifyReceived }.
     * @param resource the address of the resource for which the event needs to be monitored.
     * @param event the event name, as specified in the event package RFC.
     * @param expires the expiration period in seconds.
     * @param content optional content of the subscription.
     * @return a LinphoneEvent representing the subscription context.
     */
    public LinphoneEvent subscribe(LinphoneAddress resource, String event, int expires, LinphoneContent content);

    /**
     * Create an outgoing subscription, specifying the destination resource, the event name, and an optional content body.
     * If accepted, the subscription runs for a finite period, but is automatically renewed if not terminated before.
     * Unlike linphone_core_subscribe() the subscription isn't sent immediately. It will be send when calling linphone_event_send_subscribe().
     * @param resource the destination resource
     * @param event the event name
     * @param expires the whished duration of the subscription
     * @param body an optional body, may be NULL.
     * @return a LinphoneEvent holding the context of the created subcription.
     */
    public LinphoneEvent createSubscribe(LinphoneAddress resource, String event, int expires);

    /**
     * Create a publish context for an event state.
     * After being created, the publish must be sent using linphone_event_send_publish().
     * After expiry, the publication is refreshed unless it is terminated before.
     * @param resource the resource uri for the event
     * @param event the event name
     * @param expires the lifetime of the publication
     * @return the LinphoneEvent holding the context of the publish.
     */
    public LinphoneEvent createPublish(LinphoneAddress resource, String event, int expires);

    /**
     * Publish an event.
     * After the initial publication, updates can be done with { @link LinphoneEvent.updatePublish() }
     * @param resource the resource to which the event belongs.
     * @param event the event name as specified in the event package RFC.
     * @param expires valid time for the event.
     * @param content content of the publish.
     * @return a LinphoneEvent representing the publish context.
     */
    public LinphoneEvent publish(LinphoneAddress resource, String event, int expires, LinphoneContent content);

    /**
     * Sets the path to the database where the chat messages will be stored (if enabled)
     * @param path the database where the chat messages will be stored.
     */
    public void setChatDatabasePath(String path);

    /**
     * Sets the path to the database where the logs will be stored (if enabled)
     * @param path the database where the logs will be stored.
     */
    public void setCallLogsDatabasePath(String path);

    /**
     * Sets the path to the database where the friends will be stored (if enabled)
     * @param path the database where the friends will be stored.
     */
    public void setFriendsDatabasePath(String path);

    /**
     * Gets the chat rooms
     * @return an array of LinphoneChatRoom
     */
    public LinphoneChatRoom[] getChatRooms();

    /**
     * Gets the linphonecore supported resolutions for video
     * @return an array of String
     */
    public String[] getSupportedVideoSizes();

    /**
     * Migrate configuration so that all SIP transports are enabled.
     * Versions of linphone < 3.7 did not support using multiple SIP transport simultaneously.
     * This function helps application to migrate the configuration so that all transports are enabled.
     * Existing proxy configuration are added a transport parameter so that they continue using the unique transport that was set previously.
     * This function must be used just after creating the core, before any call to linphone_core_iterate()
     * @returns 1 if migration was done, 0 if not done because unnecessary or already done, -1 in case of error.
     */
    public int migrateToMultiTransport();

    /**
     * Migrates the call logs from the linphonerc to the database if not done yet
     **/
    public void migrateCallLogs();

    /**
     * When receiving an incoming, accept to start a media session as early-media.
     * This means the call is not accepted but audio & video streams can be established if the remote party supports early media.
     * However, unlike after call acceptance, mic and camera input are not sent during early-media, though received audio & video are played normally.
     * The call can then later be fully accepted using linphone_core_accept_call() or linphone_core_accept_call_with_params().
     * @param lc the linphonecore
     * @param call the call
     * @param params the call params, can be NULL.
     * @return true if successful, false otherwise.
     */
    public boolean acceptEarlyMedia(LinphoneCall call);

    /**
     * Accept an early media session for an incoming call.
     * This is identical as calling linphone_core_accept_early_media_with_params() with NULL call parameters.
     * @see linphone_core_accept_early_media_with_params()
     * @param call the incoming call
     * @param params
     * @return true if successful, false otherwise.
     */
    public boolean acceptEarlyMediaWithParams(LinphoneCall call, LinphoneCallParams params);

    /**
     * Creates a proxy config using the default values if they exists
     * @return a default proxy config
     */
    public LinphoneProxyConfig createProxyConfig();
    public LinphoneProxyConfig createProxyConfig(String identity,String proxy,String route, boolean enableRegister) throws LinphoneCoreException;

    /**
     * Assign an audio file to played locally upon call failure, for a given reason.
     * @param reason the #LinphoneReason representing the failure error code.
     * @param path a wav file to be played when such call failure happens.
     */
    public void setCallErrorTone(Reason reason, String path);

    /**
     * Assign an audio file to be played locally in replacement of common telephony tone.
     * This is typically used to internationalize tones.
     * @param id a tone id
     * @param wav a path to a 16 bit PCM linear wav file.
     */
    public void setTone(ToneID id, String wavfile);

    /**
     * Inform the core about the maximum transmission unit of the network.
     * This is used for fragmenting video RTP packets to a size compatible with the network.
     * @param mtu the MTU in bytes.
     */
    public void setMtu(int mtu);
    /**
     * Returns the mtu value previously set by setMtu().
     *
     * @return the MTU in bytes.
     */
    public int getMtu();
    /**
    Control when media offer is sent in SIP INVITE.
     * @param enable true if INVITE has to be sent whitout SDP.
     * */
    public void enableSdp200Ack(boolean enable);
    /**
     * Media offer control param for SIP INVITE.
     * @return true if INVITE has to be sent whitout SDP.
     */
    public boolean isSdp200AckEnabled();

    /**
     * Inconditionnaly disable incoming chat messages.
     * @param lc the core
     * @param deny_reason the deny reason (using ReasonNone has no effect).
    **/
    public void disableChat(Reason denycode);

    /**
     * Enable reception of incoming chat messages.
     * By default it is enabled but it can be disabled with linphone_core_disable_chat().
     * @param lc the core
    **/
    public void enableChat();


    /**
     * Returns whether chat is enabled.
     * @return true if chat is enabled, false otherwise.
    **/
    public boolean chatEnabled();

    /**
     * Whenever the liblinphone is playing a ring to advertise an incoming call or ringback of an outgoing call, this function stops the ringing.
     * Typical use is to stop ringing when the user requests to ignore the call.
    **/
    public void stopRinging();

    /**
     * Set audio jitter buffer size in milliseconds.
     * A value of zero disables the jitter buffer.
     * The new value is taken into account immediately for all running or pending calls.
     * @param value the jitter buffer size in milliseconds.
     */
    public void setAudioJittcomp(int value);

    /**
     * Set video jitter buffer size in milliseconds.
     * A value of zero disables the jitter buffer.
     * The new value is taken into account immediately for all running or pending calls.
     * @param value the jitter buffer size in milliseconds.
     */
    public void setVideoJittcomp(int value);

    /**
     * Globaly set an http file transfer server to be used for content type application/vnd.gsma.rcs-ft-http+xml.
     * @param serverUrl URL of the file server like https://file.linphone.org/upload.php
     */
    public void setFileTransferServer(String serverUrl);

    /**
     * Get the globaly set http file transfer server to be used for content type application/vnd.gsma.rcs-ft-http+xml.
     * @return the serverUrl
     */
    public String getFileTransferServer();

    /**
     * Create a media player
     * @return An object that implement LinphonePlayer
     */
    public LinphonePlayer createLocalPlayer(AndroidVideoWindowImpl window);

    /**
     * Adds a new listener to be called by the core
     * @param listener to add
     */
    public void addListener(LinphoneCoreListener listener);

    /**
     * Removes a listener previously added with addListener
     * @param listener to remove
     */
    public void removeListener(LinphoneCoreListener listener);

    /**
     * Specifies a ring back tone to be played to far end during incoming calls, when early media is requested.
     * @param file
     */
    public void setRemoteRingbackTone(String file);

    /**
     * Return the ringback tone file used when doing early media. It may be null.
     * @return the ringback tone file path.
     */
    String getRemoteRingbackTone();

    /**
     * Upload the log collection to the configured server url.
     */
    public void uploadLogCollection();

    /**
     * Reset the log collection by removing the log files.
     */
    public void resetLogCollection();


    /**
     * Use to set multicast address to be used for audio stream.
     * @param ip an ipv4/6 multicast address
     * @return 
     * @thow LinphoneCoreException
    **/
    public void setAudioMulticastAddr(String ip) throws LinphoneCoreException;
    /**
     * Use to set multicast address to be used for video stream.
     * @param ip an ipv4/6 multicast address
     * @thow LinphoneCoreException
    **/
    public void setVideoMulticastAddr(String ip) throws LinphoneCoreException;

    /**
     * Use to get multicast address to be used for audio stream.
     * @return an ipv4/6 multicast address or default value
    **/
    public String getAudioMulticastAddr();

    /**
     * Use to get multicast address to be used for video stream.
     * @return an ipv4/6 multicast address, or default value
    **/
    public String getVideoMulticastAddr();

    /**
     * Use to set multicast ttl to be used for audio stream.
     * @param ttl value or -1 if not used. [0..255] default value is 1
     * @thow LinphoneCoreException
    **/
    public void setAudioMulticastTtl(int ttl)  throws LinphoneCoreException;
    /**
     * Use to set multicast ttl to be used for video stream.
     * @param  ttl value or -1 if not used. [0..255] default value is 1
     * @thow LinphoneCoreException
    **/
    public void setVideoMulticastTtl(int ttl) throws LinphoneCoreException;

    /**
     * Use to get multicast ttl to be used for audio stream.
     * @return a time to leave value
     * @thow LinphoneCoreException
     *  **/
    public int getAudioMulticastTtl();

    /**
     * Use to get multicast ttl to be used for video stream.
     * @return a time to leave value
     * @thow LinphoneCoreException
    **/
    public int getVideoMulticastTtl();


    /**
     * Use to enable multicast rtp for audio stream.
     * * If enabled, outgoing calls put a multicast address from {@link linphone_core_get_video_multicast_addr} into audio cline. In case of outgoing call audio stream is sent to this multicast address.
     * <br> For incoming calls behavior is unchanged.
     * @param yesno if yes, subsequent calls will propose multicast ip set by {@link linphone_core_set_audio_multicast_addr}
    **/
    public void enableAudioMulticast(boolean yesno);

    /**
     * Use to get multicast state of audio stream.
     * @return true if  subsequent calls will propose multicast ip set by {@link linphone_core_set_audio_multicast_addr}
    **/
    public  boolean audioMulticastEnabled();

    /**
     * Use to enable multicast rtp for video stream.
     * If enabled, outgoing calls put a multicast address from {@link linphone_core_get_video_multicast_addr} into video cline. In case of outgoing call video stream is sent to this  multicast address.
     * <br> For incoming calls behavior is unchanged.
     * @param yesno if yes, subsequent outgoing calls will propose multicast ip set by {@link linphone_core_set_video_multicast_addr}
    **/
    public void enableVideoMulticast(boolean yesno);
    /**
     * Use to get multicast state of video stream.
     * @return true if  subsequent calls will propose multicast ip set by {@link linphone_core_set_video_multicast_addr}
    **/
    public  boolean videoMulticastEnabled();

    /**
     * Enable or disable DNS SRV resolution.
     * @param yesno true to enable DNS SRV resolution, false to disable it.
     */
    public void enableDnsSrv(boolean yesno);

    /**
     * Tells whether DNS SRV resolution is enabled.
     * @return true if DNS SRV resolution is enabled, false if disabled.
     */
    public boolean dnsSrvEnabled();

    /**
     * Set the video preset to be used for video calls.
     * @param lc LinphoneCore object
     * @param preset The name of the video preset to be used (can be null to use the default video preset).
     */
    public void setVideoPreset(String preset);

    /**
     * Get the video preset used for video calls.
     * @param lc LinphoneCore object
     * @return The name of the video preset used for video calls (can be null if the default video preset is used).
     */
    public String getVideoPreset();

    /**
     * Set a provisioning URI to fetch an xml linphonerc config file from, at next LinphoneCore instantiation.
    **/
    public void setProvisioningUri(String uri);

    /**
     * Get the provisioning URI previously set.
    **/
    public String getProvisioningUri();

    /**
     * Set an http proxy hostname or IP address to use for SIP connection.
     */
    public void setHttpProxyHost(String host);
    /**
     * Set an http proxy port to use for SIP connection.
     */
    public void setHttpProxyPort(int port);
    /**
     * Get the http proxy host previously set.
    **/
    public String getHttpProxyHost();
    /**
     * Get the http proxy port previously set.
    **/
    public int getHttpProxyPort();

    /*
     * Set the nortp timeout (timeout after which call is closed if no RTP or RTCP packets are received).
     */
    public void setNortpTimeout(int seconds);

    /**
     * Get the nortp timeout.
     * @return
     */
    public int getNortpTimeout();

    /**
     * This method is called by the application to notify the linphone core library when the SIP network is reachable.
     * This is for advanced usage, when SIP and RTP layers are required to use different interfaces.
     * Most applications just need LinphoneCore.setNetworkReachable().
     * @param isReachable whether SIP network is reachable.
     */
    public void setSipNetworkReachable(boolean isReachable);

    /**
     * This method is called by the application to notify the linphone core library when the media (RTP) network is reachable.
     * This is for advanced usage, when SIP and RTP layers are required to use different interfaces.
     * Most applications just need LinphoneCore.setNetworkReachable().
     * @param isReachable whether media network is reachable.
     */
    public void setMediaNetworkReachable(boolean isReachable);

    /**
     * Returns the mediastreamer2 (media stack) factory object used by the LinphoneCore. This may be useful to perform
     * some advanced media-related configuration options.
    **/
    org.linphone.mediastream.Factory getMSFactory();

    /**
     * Overrides the list of DNS servers to use.
     * Passing null restores the default behaviour, which is to use the dns server list provided by the system.
    **/
    public void setDnsServers(String servers[]);

    /**
     * Set user certificates directory path (used by SRTP-DTLS).
     */
    public void setUserCertificatesPath(String path);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299
2300
2301
2302
2303
2304
2305
2306