gt:             OnCallAnswered answered = (OnCallAnswered) message;
context: package im.actor.core.modules.calls;
  
  import java.util.HashMap;
  import java.util.HashSet;
  
  import im.actor.core.entity.Peer;
  import im.actor.core.modules.ModuleContext;
  import im.actor.core.modules.calls.peers.AbsCallActor;
  import im.actor.core.modules.ModuleActor;
  import im.actor.core.providers.CallsProvider;
  import im.actor.core.util.RandomUtils;
  import im.actor.core.viewmodel.CommandCallback;
  import im.actor.runtime.*;
  import im.actor.runtime.Runtime;
  import im.actor.runtime.actors.Actor;
  import im.actor.runtime.actors.ActorCreator;
  import im.actor.runtime.actors.ActorRef;
  import im.actor.runtime.actors.messages.PoisonPill;
  import im.actor.runtime.function.Constructor;
  import im.actor.runtime.power.WakeLock;
  
  public class CallManagerActor extends ModuleActor {
  
      public static ActorCreator CONSTRUCTOR(final ModuleContext context) {
          return () -> new CallManagerActor(context);
      }
  
      private static final String TAG = "CallManagerActor";
  
      private CallsProvider provider;
      private HashSet<Long> handledCalls = new HashSet<>();
      private HashMap<Long, Integer> handledCallAttempts = new HashMap<>();
      private HashSet<Long> answeredCalls = new HashSet<>();
  
      private Long currentCall;
      private HashMap<Long, ActorRef> runningCalls = new HashMap<>();
      private boolean isBeeping = false;
  
      public CallManagerActor(ModuleContext context) {
          super(context);
      }
  
      @Override
      public void preStart() {
          super.preStart();
          provider = config().getCallsProvider();
      }
  
  
      //
      // Outgoing call
      //
  
      private void doCall(final Peer peer, final CommandCallback<Long> callback, boolean isVideoEnabled) {
          Log.d(TAG, "doCall (" + peer + ")");
  
          //
          // Stopping current call as we started new done
          //
          if (currentCall != null) {
              terminalCall(currentCall);
              currentCall = null;
          }
  
          //
          // Spawning new Actor for call
          //
          final WakeLock wakeLock = Runtime.makeWakeLock();
          system().actorOf("actor/master/" + RandomUtils.nextRid(), () -> {
              return new CallActor(peer, callback, wakeLock, isVideoEnabled, context());
          });
      }
  
      private void onCallCreated(long callId, ActorRef ref) {
  
          //
          // Stopping current call some are started during call establishing
          //
          if (currentCall != null) {
              terminalCall(currentCall);
              currentCall = null;
  
              if (isBeeping) {
                  isBeeping = false;
                  provider.stopOutgoingBeep();
              }
          }
  
          //
          // Saving Reference to call
          //
          runningCalls.put(callId, ref);
  
          //
          // Marking outgoing call as answered
          //
          answeredCalls.add(callId);
  
          //
          // Setting Current Call
          //
          currentCall = callId;
  
          //
          // Notify Provider about new current call
          //
          provider.onCallStart(callId);
          isBeeping = true;
          provider.startOutgoingBeep();
      }
  
  
      //
      // Incoming call
      //
  
      private void onIncomingCall(final long callId, final int attempt, WakeLock wakeLock) {
          Log.d(TAG, "onIncomingCall (" + callId + ")");
  
          //
          // Filter double updates about incoming call
          //
          if (handledCalls.contains(callId)) {
              if (handledCallAttempts.get(callId) >= attempt) {
                  if (wakeLock != null) {
                      wakeLock.releaseLock();
                  }
                  return;
              }
          }
  
          //
          // Ignore any incoming call if we already have running call with such call id
          //
          if (runningCalls.containsKey(callId)) {
              if (wakeLock != null) {
                  wakeLock.releaseLock();
              }
              return;
          }
  
          //
          // Marking handled calls as handled
          //
          handledCalls.add(callId);
          handledCallAttempts.put(callId, attempt);
  
          //
          // Creating wake lock if needed
          //
          if (wakeLock == null) {
              wakeLock = Runtime.makeWakeLock();
          }
  
          //
          // Spawning new Actor for call
          //
          final WakeLock finalWakeLock = wakeLock;
          system().actorOf("actor/call" + RandomUtils.nextRid(), () -> {
              return new CallActor(callId, finalWakeLock, context());
          });
      }
  
      private void onIncomingCallReady(long callId, ActorRef ref) {
  
          //
          // Saving reference to incoming call
          //
          runningCalls.put(callId, ref);
  
          //
          // Change Current Call if there are no ongoing calls now
          //
          if (currentCall == null) {
              currentCall = callId;
              provider.onCallStart(callId);
          }
      }
  
      private void onIncomingCallHandled(long callId) {
  
          // If We are not answered this call on this device
          if (!answeredCalls.contains(callId)) {
  
              //
              // Notify provider
              //
              if (currentCall != null && currentCall == callId) {
                  currentCall = null;
                  provider.onCallEnd(callId);
              }
  
              //
              // Shutdown call actor
              //
              terminalCall(callId);
          }
      }
  
      private void doAnswerCall(final long callId) {
          Log.d(TAG, "doAnswerCall (" + callId + ")");
  
          // If not already answered
          if (!answeredCalls.contains(callId)) {
  
              //
              // Mark as answered
              //
              answeredCalls.add(callId);
  
              //
              // Sending answer message to actor.
              //
              ActorRef ref = runningCalls.get(callId);
              if (ref != null) {
                  ref.send(new CallActor.AnswerCall());
              }
  
              //
              // Notify Provider to stop playing ringtone
              //
              if (currentCall != null && currentCall == callId) {
                  provider.onCallAnswered(callId);
              }
          }
      }
  
      private void onCallAnswered(long callId) {
          Log.d(TAG, "onCallAnswered (" + callId + ")");
          if (currentCall == callId) {
              if (isBeeping) {
                  isBeeping = false;
                  provider.stopOutgoingBeep();
              }
  
              provider.onCallAnswered(callId);
          }
      }
  
      //
      // Call AudioEnabled/Unmute
      //
      private void onCallAudioEnable(long callId) {
          ActorRef ref = runningCalls.get(callId);
          if (ref != null) {
              ref.send(new AbsCallActor.AudioEnabled(true));
          }
      }
  
      private void onCallAudioDisable(long callId) {
          ActorRef ref = runningCalls.get(callId);
          if (ref != null) {
              ref.send(new AbsCallActor.AudioEnabled(false));
          }
      }
  
      //
      // Call video disable/enable
      //
      private void onCallVideoEnable(long callId) {
          ActorRef ref = runningCalls.get(callId);
          if (ref != null) {
              ref.send(new AbsCallActor.VideoEnabled(true));
          }
      }
  
      private void onCallVideoDisable(long callId) {
          ActorRef ref = runningCalls.get(callId);
          if (ref != null) {
              ref.send(new AbsCallActor.VideoEnabled(false));
          }
      }
  
      //
      // Ending call
      //
  
      private void onCallEnded(long callId) {
          Log.d(TAG, "onCallEnded (" + callId + ")");
  
          //
          // Event ALWAYS comes from Call Actor and we doesn't need
          // to stop it explicitly.
          //
          // Removing from running calls
          //
          runningCalls.remove(callId);
  
          //
          // Notify Provider if this call was current
          //
          if (currentCall != null && currentCall == callId) {
              currentCall = null;
              provider.onCallEnd(callId);
  
              if (isBeeping) {
                  isBeeping = false;
                  provider.stopOutgoingBeep();
              }
          }
      }
  
      private void doEndCall(long callId) {
          Log.d(TAG, "doEndCall (" + callId + ")");
  
          //
          // Action ALWAYS comes from UI side and we need only stop call actor
          // explicitly and it will do the rest.
          //
          ActorRef currentCallActor = runningCalls.remove(callId);
          if (currentCallActor != null) {
              if (answeredCalls.contains(callId)) {
                  currentCallActor.send(PoisonPill.INSTANCE);
              } else {
                  currentCallActor.send(new CallActor.RejectCall());
              }
          }
  
          //
          // Notify Provider if this call was current
          //
          if (currentCall != null && currentCall == callId) {
              currentCall = null;
              provider.onCallEnd(callId);
              if (isBeeping) {
                  isBeeping = false;
                  provider.stopOutgoingBeep();
              }
          }
      }
  
      private void probablyEndCall() {
          if (currentCall != null) {
              doEndCall(currentCall);
          }
      }
  
      private void terminalCall(long callId) {
          ActorRef dest = runningCalls.remove(callId);
          if (dest != null) {
              dest.send(PoisonPill.INSTANCE);
          }
      }
  
      private void sendToCall(long callId, Object message) {
          ActorRef dest = runningCalls.get(callId);
          if (dest != null) {
              dest.send(message);
          }
      }
  
  
      //
      // Messages
      //
  
      @Override
      public void onReceive(Object message) {
          if (message instanceof OnIncomingCall) {
              OnIncomingCall call = (OnIncomingCall) message;
              onIncomingCall(call.getCallId(), call.getAttempt(), null);
          } else if (message instanceof OnIncomingCallLocked) {
              OnIncomingCallLocked locked = (OnIncomingCallLocked) message;
              onIncomingCall(locked.getCallId(), locked.getAttempt(), locked.getWakeLock());
          } else if (message instanceof OnIncomingCallHandled) {
              OnIncomingCallHandled incomingCallHandled = (OnIncomingCallHandled) message;
              onIncomingCallHandled(incomingCallHandled.getCallId());
          } else if (message instanceof DoAnswerCall) {
              doAnswerCall(((DoAnswerCall) message).getCallId());
          } else if (message instanceof DoEndCall) {
              doEndCall(((DoEndCall) message).getCallId());
          } else if (message instanceof OnCallEnded) {
              onCallEnded(((OnCallEnded) message).getCallId());
          } else if (message instanceof DoCall) {
              DoCall doCall = (DoCall) message;
              doCall(doCall.getPeer(), doCall.getCallback(), doCall.isEnableVideoCall());
          } else if (message instanceof DoCallComplete) {
              DoCallComplete callCreated = (DoCallComplete) message;
              onCallCreated(callCreated.getCallId(), sender());
          } else if (message instanceof IncomingCallReady) {
              IncomingCallReady callComplete = (IncomingCallReady) message;
              onIncomingCallReady(callComplete.getCallId(), sender());
          } else if (message instanceof OnCallAnswered) {
  