!7

p {

  language = currentBotLanguage();

  muteAlways = false;

  fastSynthesis = true;

  manualMode = false;

  halfAutoMode = false; // listen again when something was heard

  androidCatMain();

}

set flag NoAWT. set flag Android.

import android.app.*;

import android.content.*;

import android.os.Bundle;

import android.view.View;

import android.view.View.OnClickListener;

import android.speech.RecognitionListener;

import android.speech.RecognizerIntent;

import android.speech.SpeechRecognizer;

import android.widget.Button;

import android.widget.TextView;

import android.util.Log;

import android.media.*;

sS earURL = "http://botcompany.de:8083";

static SpeechRecognizer sr;

static final String TAG = "MyStt3Activity";

static S language = "en-US";

static int extraResults = 1;

static bool fastSynthesis = false; // use device voice (faster)

static bool noSpeech = false; // disable speech output

static bool manualMode = false; // Start recognition on click only

sbool halfAutoMode;

sbool muteAlways, printErrors;

sbool listenAfterTalk = true; // it works now

static volatile bool listening, recognitionCancelled;

static new L<S> history;

static Lock speechLock = lock();

static boolean showPicture = true; // global switch. if false, you get the normal text display instead of the smiley

static L<S> emotions = litlist(

  "#1001283", "happy",

  "#1001284", "unhappy",

  "#1001285", "oh",

  "#1001286", "bored",

  "#1001287", "wide mouth");

static float statusFontSize = /*25*/17;

static float userFontSize = 25;

static float myFontSize = 25;

static int borderColor = 0xFFFFFFFF;

static int waitColor = /*0xFFFF0000*/ 0xFFFFFF00; // yellow

static S lastEmotionImage, lastEmotion /*, onScreenText = ""*/;

static ImageView emoView;

static TextView statusView, userTextView, myTextView, lblInputView;

static LinearLayout leftFlag, rightFlag;

sS statusText;

static EditText inputView;

sbool recogOnActivate = true; // start listening when app activated

sbool hideTitleBar;

static CatConnector connector;

static LS postponed = syncList(); // output lines postponed because user is speaking

svoid androidCatMain {

  if (androidIsAdminMode()) {

    print("Going admin.");

    androidUnsetAdminMode();

    removeMyselfAsInjection();

    aShowStartScreen();

    ret;

  }

  if (hideTitleBar) aHideTitleBar();

  androidSay_keepEngine = true;

  if (muteAlways) androidMuteAudio();

  S hello = null;

  /*if (args.length != 0 && args[0].equals("nogfx"))

    setOpt(getMainClass(), "showPicture", false);*/

  try {

    history.add("*");

    //hello = callStaticAnswerMethod("*", history);

    if (hello == null) hello = german() ? "hallo" : "hello";

  } catch (Throwable e) {

    e.printStackTrace();

    return;

  }

  if (!androidIsAdminMode())

    aClearConsole();

  listening = true; // so user can cancel early

  //if (!noSpeech) say(hello);

  justASec(); // show interface

  callOptMC('happy);

  connector = new CatConnectorImpl(androidAssistant_token()); 

  connector.startEar(vf<S> say);

  // setLanguage(language);

  aAddMenuItems("Switch to manual mode", "Switch to auto mode");

  // init engine?

  if (german()) androidSayInGerman(""); else androidSayInEnglish("");

  if (recognitionCancelled) recognitionCancelled = false;

  else

    androidUI(f newRecognizer);

  noMainDone();

}

static void newRecognizer() {

  //print("listening");

  listening = true;

  sr = SpeechRecognizer.createSpeechRecognizer(androidActivity());

  sr.setRecognitionListener(new listener());        

  recog();

}

static class listener implements RecognitionListener {

  public void onReadyForSpeech(Bundle params) {

    if (recognitionCancelled) {

      recognitionCancelled = false;

      sr.stopListening();

      ret;

    }

    callOptMC('setBorderAndStatus, 0xFF66FF66,

      german() ? "JETZT SPRECHEN!" : "TALK NOW!");

    callOptMC('oh);

    //showText(german() ? "SAG WAS." : "TALK NOW.");

  }

  public void onBeginningOfSpeech() {

    //showText("User talks");

    //callOptMC('oh);

    if (!manualMode && !muteAlways)

      androidMuteAudio(); // Mute now, so we don't hear the end-of-speech sound

  }

  public void onRmsChanged(float rmsdB) {}

  public void onBufferReceived(byte[] buffer) {}

  public void onEndOfSpeech() {

    ping();

    //showText("onEndOfSpeech");

    callOptMC('setBorderAndStatus, aWhite(), baseStatus());

  }

  public void onError(int error) {

     ping();

     listening = false;

     if (printErrors)

       if (error == 6) // timeout

         print("speech timeout");

       else

         print("error " +  error); // screw the errors!

     try {

       sr.destroy();

     } catch (Throwable e) {

       print(e);

     }

     if (!manualMode)

       newRecognizer();

     else

      callOptMC('setBorderAndStatus, aWhite(), baseStatus());

     callOpt(getMainClass(), "happy");

  }

  public void onResults(Bundle results) {

    ping();

    listening = false;

    //showText("onResults");

    ArrayList<S> data = results.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION);

    fS s = data.get(0);

    onInput(s, false);

  }

  public void onPartialResults(Bundle partialResults) {

    print("onPartialResults");

  }

  public void onEvent(int eventType, Bundle params) {

    print("onEvent" + eventType);

  }

}

svoid onInput(S _s, final bool typed) {

  fS s = trim(_s); if (empty(s)) ret;

  thread "onInput" {

    connector.sendLine(s, typed);

    aSetText(userTextView, lang("You: ", "Du: ") + s);

    aPutViewBehindOtherView(userTextView, myTextView);

    showText(

      (typed 

        ? lang("You typed: ", "Du schrubst: ")

        : lang("I heard: ", "Ich habe geh\u00f6rt: ")) + quote(s));

    // TODO: fix the java strings umlaut problem

    final boolean goodbye = match3("goodbye", s) || match3("bye", s) || match3("tsch\u00fcss", s) || match3("tsch\u00fcss ...", s);

    // get answer

    history.add(s);

    handleCommand(s);

    S answer;

    try {

      answer = goodbye ? "tsch\u00fcss" : callStaticAnswerMethod(s, history);

    } catch (Throwable e) {

      e.printStackTrace();

      appendToFile(getProgramFile("errors.txt"), getTheStackTrace(e));

      answer = "Fehler";

    }

    if (answer != null)

      print(answer);

    androidUI(r {

      if (goodbye) {

        print("\nGOODBYE!");

        sr.destroy();

        callOpt(getMainClass(), "disappear");

      } else {

        print("No goodbye");

        sr.stopListening();

        listening = false;

        //newRecognizer(); // always make a new one - gives endless errors

        if (!manualMode || halfAutoMode)

          recog();

      }

    });

  } // end of thread

}

svoid recog() {

  if (sr == null) ret with newRecognizer();

  print("recog");

  listening = true;

  justASec();

  Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);        

  intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL,RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);

  intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE, language);

  intent.putExtra(RecognizerIntent.EXTRA_CALLING_PACKAGE,"voice.recognition.test");

  intent.putExtra(RecognizerIntent.EXTRA_MAX_RESULTS, extraResults); 

  // customize recognition time settings

  callOpt(mc(), "recogTimeSettings", intent);

  sr.startListening(intent);

  print("started listening");

}

svoid say(fS s) {

  ping();

  lock speechLock;

  showText(">> " + s);

  aSetText(myTextView, lang("Me: ", "Ich: ") + s);

  aPutViewBehindOtherView(myTextView, userTextView);

  if (manualMode && listening) {

    print("User is speaking, postponing speech output.");

    postponed.add(s);

    ret;

  }

  androidUI_wait(f stopListening);

  history.add(s);

  if (!noSpeech) {

    androidUnmuteAudio();

    callOptMC('oh);

    if (fastSynthesis) {

      if (german()) androidSayInGerman(s); else androidSayInEnglish(s);

    } else {

      File mp3 = cereproc_silent(german() ? "Leopold" : "Jack", s);

      androidPlayMp3(androidActivity(), mp3);

    }

    callOptMC('happy);

    if (listenAfterTalk)

      //androidUI_noWait(r startListening); // works, but freezes UI

      androidUI_noWait(r newRecognizer);

  }

  if (muteAlways)

    androidMuteAudio();

}

static void stopListening() {

  listening = false;

  if (sr != null)

    sr.stopListening();

}

svoid startListening() {

  if (listening) ret;

  listening = true;

  recog();

}

sbool german() {

  ret swic(language, "de");

}

svoid switchToManual {

  stopListening();

  manualMode = true;

  androidUnmuteAudio();

}

svoid switchToAuto {

  manualMode = false;

  startListening();

  androidUnmuteAudio();

}

svoid onMenuCommand(S s) {

  //print("menu cmd: " + s);

  handleCommand(s);

}

// spoken, typed or through menu

svoid handleCommand(S s) {

  if "stop listening|Switch to manual mode" switchToManual();

  if "Switch to auto mode" switchToAuto();

  if "german|deutsch" setLanguage("de-DE");

  if "english|englisch" setLanguage("en-US");

}

svoid cleanMeUp_leo {

  if (sr != null) {

    sr.destroy();

    sr = null;

  }

}

sS baseStatus() {

  ret !manualMode ? "" :

    german() ? "KLICKEN ZUM SPRECHEN" : "CLICK ON ME IF YOU WANT TO TALK";

}

sS lang(S en, S de) {

  ret german() ? de : en;

}

svoid setLanguage(S l) {

  language = l;

  setCurrentBotLanguage(l);

  aSetText(lblInputView, inputViewLabel());

  androidUI_noWait(r newRecognizer);

}

svoid justASec {

  callOptMC('setBorderAndStatus, waitColor,

    german() ? "BITTE WARTEN" : "JUST A SEC"); // (initializing speech recognizer)

}

// Don't use - freezes UI

svoid _cancelRecognition {

  //print("Cancelling recognition " + listening + " " + (sr != null));

  recognitionCancelled = true;

  //stopListening();

  //listening = false;

  //if (sr != null) sr.cancel();

  //callOptMC('setBorderAndStatus, aWhite(), baseStatus());

}

static void showText(S text) {

  print(text);

  /*if (neq(onScreenText, text) && lastEmotion != null) {

    onScreenText = text;

    emo_show();

  }*/

}

static void emo(S emotion) {

  if (!showPicture) return;

  int i;

  for (i = 0; i < emotions.size(); i += 2)

    if (emotions.get(i+1).equalsIgnoreCase(emotion))

      break;

  if (i >= emotions.size()) {

    print("Emotion not found: " + emotion);

    // use the last one from the list as default

    i -= 2;

  }

  lastEmotionImage = emotions.get(i);

  lastEmotion = emotions.get(i+1);

  emo_show();

}

static void emo_show() {

  if (!showPicture) return;

  androidUI {

    Runnable onClick = r {

      if (!manualMode) ret;

      //if (listening)

      if (borderColor != -1) {

        //androidLater(500, r { stopListening(); });

        //showText("stop");

        stopListening();

      } else {

        //showText ("start");

        newRecognizer();

      }

    };

    if (statusView == null) {

      // init UI

      statusView = aFontSize(statusFontSize, aSetForeground(aBlack(), aCenteredTextView()));

      inputView = aSingleLineEditText();

      aOnEnter(inputView, r { onInput(aGetText(inputView), true) });

      //aOnChange(inputView, f cancelRecognition); // freezes!?

      //aOnChange(inputView, r { listening = false });

      //aOnChange(inputView, f cancelRecognition);

      lblInputView = aFontSize(20, aBottomTextView(inputViewLabel()));

      userTextView = aFontSize(userFontSize, aSetForeground(0xFF000055, aTextViewWithWindowFocusChangeNotify(voidfunc(Bool windowFocused) {

        print("windowFocusChange " + windowFocused);

        if (windowFocused) {

          //if (recogOnActivate) newRecognizer(); // let the server do it now

          thread { connector.sendEvent('windowFocused); }

        }

      })));

      myTextView = aFontSize(myFontSize, aSetForeground(0xFF005500, aRightAlignedTextView());

      androidShow(aVerticalLinearLayout(

        statusView,

        aWestCenterAndEast/*_alignTop2*/(

          leftFlag = aVerticalLinearLayout(androidClickableImage(#1101639, 0 /*transparent*/, r { setLanguage("en-US") })),

          emoView = androidClickableImage(lastEmotionImage, aWhite(), onClick),

          rightFlag = aVerticalLinearLayout(androidClickableImage(#1101638, 0 /*transparent*/, r { setLanguage("de-DE") }))

        ),

        userTextView,

        myTextView,

        androidPrintLogScrollView(),

        aWestAndCenter(lblInputView, inputView)));

    }

    if (statusText == null) statusText = baseStatus();

    aSetText(statusView, statusText);

    aSetImageFromSnippet(emoView, lastEmotionImage);

    aSetBackground(emoView, borderColor);

    aSetBackground(eq(language, "en-US") ? borderColor : 0xFFCCCCCC, leftFlag);

    aSetBackground(eq(language, "de-DE") ? borderColor : 0xFFCCCCCC, rightFlag);

    /*doEvery(1000, new Runnable {

      S text = "";

      public void run() {

        S s = aGetText(inputView);

        if (eq(s, text)) ret;

        text = s;

        cancelRecognition();

      }

    });*/

  }

}

static void setBorderAndStatus(int color, S status) {

  if (color != borderColor || neq(status, statusText)) {

    borderColor = color;

    statusText = status;

    if (lastEmotion != null)

      emo(lastEmotion);

    if (!(manualMode && listening) && nempty(postponed))

      for (S s : getAndClearList(postponed))

        say(s);

  }

}

static void setBorderColor(int color) {

  if (color != borderColor) {

    borderColor = color;

    if (lastEmotion != null)

      emo(lastEmotion);

  }

}

static void happy() { emo("happy"); }

static void unhappy() { emo("unhappy"); }

static void oh() { emo("oh"); }

static void bored() { emo("bored"); }

static void wideMouth() { emo("wide mouth"); }

static void disappear() {

  if (!showPicture) ret;

  happy();

  androidLater(1000, r {

    androidShowFullScreenColor(0xFFFFFFFF);

    androidLater(1000, r {

      System.exit(0); // totally unrecommended but works

    });

  });

}

sS inputViewLabel() {

  ret lang("Or type here:", "Oder hier tippen:");

}

sinterface CatConnector {

  void sendLine(S line, bool typed);

  void sendEvent(S event);

  AutoCloseable startEar(VF1<S> onLine);

}

sclass CatConnectorImpl implements CatConnector {

  S token;

  *() {}

  *(S *token) {}

  public void sendLine(S line, bool typed) {

    postPage(earURL + "/heard", +token, +line, typed := typed ? "1" : null, +language);

  }

  public void sendEvent(S event) {

    postPage(earURL + "/event", +token, what := event, +language);

  }

  public AutoCloseable startEar(final VF1<S> onLine) {

    thread "Long-Poll" {

      repeat with sleep 1 {

        pcall {

          // TODO: interrupt connection on cleanup

          S action = postPageSilently(earURL + "/poll", +token);

          for (S s : lines(action))

            pcallF(onLine, s);

        }

      }

    }

    null;

  }

}