         case waitingPeer
     }
     
-    public var handlers: MediaChannelHandlers = MediaChannelHandlers()
-
-    public var configuration: Configuration
-    public var clientId: String?
-    public var peerChannel: PeerChannel
+    public let handlers: MediaChannelHandlers = MediaChannelHandlers()
+    
+    public let configuration: Configuration
+    public private(set) var clientId: String?
+    public let peerChannel: PeerChannel
     
     public var streams: [MediaStream] {
-        get { return peerChannel.streams }
+        return peerChannel.streams
     }
     
     public var mainStream: MediaStream? {
-        get { return streams.first }
+        return streams.first
     }
     
-    public var state: State = .disconnected {
+    public private(set) var state: State = .disconnected {
         didSet {
             Log.trace(type: .mediaChannel,
                       message: "changed state from \(oldValue) to \(state)")
         }
     }
-
-    public var aliveState: AliveState {
-        get {
-            switch state {
-            case .connected:
-                return .available
-            case .disconnecting, .disconnected:
-                return .unavailable
-            default:
-                return .connecting
-            }
-        }
-    }
     
-    private var aliveMonitor: AliveMonitor = AliveMonitor()
+    private let aliveMonitor: AliveMonitor = AliveMonitor()
     private var connectionTimer: ConnectionTimer?
     private var onConnectHandler: Callback1<Error?, Void> = Callback1(repeats: false)
     


public class MediaChannelHandlers {
    
    public var onFailureHandler: Callback1<Error, Void> = Callback1(repeats: true)
    public var onMessageHandler: Callback1<SignalingMessage, Void> = Callback1(repeats: true)
    public var onAddStreamHandler: Callback1<MediaStream, Void> = Callback1(repeats: true)
    public var onRemoveStreamHandler: Callback1<MediaStream, Void> = Callback1(repeats: true)
    public var onEventHandler: Callback1<Event, Void> =
        Callback1(repeats: true)
    
    public func onFailure(handler: @escaping (Error) -> Void) {
        onFailureHandler.onExecute(handler: handler)
    }

    public func onMessage(handler: @escaping (SignalingMessage) -> Void) {
        onMessageHandler.onExecute(handler: handler)
    }

    public func handleChannelStateChanges(objects: [AliveMonitorable]) {
        // TODO
    }
    
    public func disconnect(error: Error?) {
        switch state {
        case .disconnecting, .disconnected:
