tests/tests/voiceinteraction/service/src/android/voiceinteraction/service/MainInteractionSession.java

/*
 * Copyright (C) 2015 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.voiceinteraction.service;

import android.app.VoiceInteractor;
import android.app.VoiceInteractor.Prompt;
import android.content.Context;
import android.content.Intent;
import android.os.AsyncTask;
import android.os.Bundle;
import android.service.voice.VoiceInteractionSession;
import android.service.voice.VoiceInteractionSession.ConfirmationRequest;
import android.service.voice.VoiceInteractionSession.PickOptionRequest;
import android.util.Log;
import android.voiceinteraction.common.Utils;

import java.util.ArrayList;
import java.util.List;


public class MainInteractionSession extends VoiceInteractionSession {
    static final String TAG = "MainInteractionSession";

    Intent mStartIntent;
    List<MyTask> mUsedTasks = new ArrayList<MyTask>();

    MainInteractionSession(Context context) {
        super(context);
    }

    @Override
    public void onCreate() {
        super.onCreate();
    }

    @Override
    public void onDestroy() {
        Log.i(TAG, "Canceling the Asynctask in onDestroy()");
        for (MyTask t : mUsedTasks) {
            t.cancel(true);
        }
        super.onDestroy();
    }

    @Override
    public void onShow(Bundle args, int showFlags) {
        super.onShow(args, showFlags);
        mStartIntent = args.getParcelable("intent");
        startVoiceActivity(mStartIntent);
    }

    void assertPromptFromTestApp(CharSequence prompt, Bundle extras) {
        String str = prompt.toString();
        if (str.equals(Utils.TEST_PROMPT)) {
            Log.i(TAG, "prompt received ok from TestApp in Session");
        } else {
            Utils.addErrorResult(extras, "Invalid prompt received: " + str);
        }
    }

    synchronized MyTask newTask() {
        MyTask t = new MyTask();
        mUsedTasks.add(t);
        return t;
    }

    @Override
    public boolean[] onGetSupportedCommands(String[] commands) {
        boolean[] results = new boolean[commands.length];
        Log.i(TAG, "in onGetSupportedCommands");
        for (int idx = 0; idx < commands.length; idx++) {
            results[idx] = Utils.TEST_COMMAND.equals(commands[idx]);
            Log.i(TAG, "command is " + commands[idx]);
        }
        return results;
    }

    @Override
    public void onRequestConfirmation(ConfirmationRequest request) {
        Bundle extras = request.getExtras();
        CharSequence prompt = request.getVoicePrompt().getVoicePromptAt(0);
        Log.i(TAG, "in Session onRequestConfirmation recvd. prompt=" + prompt +
                ", extras=" + Utils.toBundleString(extras));
        assertPromptFromTestApp(prompt, extras);
        AsyncTaskArg asyncTaskArg = new AsyncTaskArg().setRequest(request).setExtras(extras);
        if (isTestTypeCancel(extras)) {
            Log.i(TAG, "Sending Cancel.");
            newTask().execute(
                    asyncTaskArg.setTestType(Utils.TestCaseType.CONFIRMATION_REQUEST_CANCEL_TEST));
        } else {
            Log.i(TAG, "in Session sending sendConfirmationResult. " +
                    Utils.toBundleString(extras));
            newTask().execute(
                    asyncTaskArg.setTestType(Utils.TestCaseType.CONFIRMATION_REQUEST_TEST));
        }
    }

    @Override
    public void onRequestCompleteVoice(CompleteVoiceRequest request) {
        Bundle extras = request.getExtras();
        CharSequence prompt = request.getVoicePrompt().getVoicePromptAt(0);
        Log.i(TAG, "in Session onRequestCompleteVoice recvd. message=" +
                prompt + ", extras=" + Utils.toBundleString(extras));
        assertPromptFromTestApp(prompt, extras);
        AsyncTaskArg asyncTaskArg = new AsyncTaskArg().setRequest(request).setExtras(extras);
        if (isTestTypeCancel(extras)) {
            Log.i(TAG, "Sending Cancel.");
            newTask().execute(
                    asyncTaskArg.setTestType(Utils.TestCaseType.COMPLETION_REQUEST_CANCEL_TEST));
        } else {
            Log.i(TAG, "in Session sending sendConfirmationResult. " +
                    Utils.toBundleString(extras));
            newTask().execute(
                    asyncTaskArg.setTestType(Utils.TestCaseType.COMPLETION_REQUEST_TEST));
        }
    }

    @Override
    public void onRequestAbortVoice(AbortVoiceRequest request) {
        Bundle extras = request.getExtras();
        CharSequence prompt = request.getVoicePrompt().getVoicePromptAt(0);
        Log.i(TAG, "in Session onRequestAbortVoice recvd. message=" +
                prompt + ", extras=" + Utils.toBundleString(extras));
        assertPromptFromTestApp(prompt, extras);
        AsyncTaskArg asyncTaskArg = new AsyncTaskArg().setRequest(request).setExtras(extras);
        if (isTestTypeCancel(extras)) {
            Log.i(TAG, "Sending Cancel.");
            newTask().execute(
                    asyncTaskArg.setTestType(Utils.TestCaseType.ABORT_REQUEST_CANCEL_TEST));
        } else {
            Log.i(TAG, "in Session sending sendAbortResult. " +
                Utils.toBundleString(extras));
            newTask().execute(asyncTaskArg.setTestType(Utils.TestCaseType.ABORT_REQUEST_TEST));
        }
    }

    @Override
    public void onRequestCommand(CommandRequest request) {
        Bundle extras = request.getExtras();
        Log.i(TAG, "in Session onRequestCommand recvd. Bundle = " +
                Utils.toBundleString(extras));

        // Make sure that the input request has Utils.TEST_COMMAND sent by TestApp
        String command = request.getCommand();
        if (command.equals(Utils.TEST_COMMAND)) {
            Log.i(TAG, "command received ok from TestApp in Session");
        } else {
            Utils.addErrorResult(extras, "Invalid TEST_COMMAND received: " + command);
        }
        // Add a field and value in the bundle to be sent to TestApp.
        // TestApp will ensure that these are transmitted correctly.
        extras.putString(Utils.TEST_ONCOMMAND_RESULT, Utils.TEST_ONCOMMAND_RESULT_VALUE);
        AsyncTaskArg asyncTaskArg = new AsyncTaskArg().setRequest(request).setExtras(extras);
        if (isTestTypeCancel(extras)) {
            Log.i(TAG, "Sending Cancel.");
            newTask().execute(
                    asyncTaskArg.setTestType(Utils.TestCaseType.COMMANDREQUEST_CANCEL_TEST));
        } else {
            Log.i(TAG, "in Session sending sendResult. " +
                    Utils.toBundleString(extras) + ", string_in_bundle: " +
                    Utils.TEST_ONCOMMAND_RESULT + " = " + Utils.TEST_ONCOMMAND_RESULT_VALUE);
            newTask().execute(asyncTaskArg.setTestType(Utils.TestCaseType.COMMANDREQUEST_TEST));
        }
    }

    void assertPickOptionsFromTestApp(VoiceInteractor.PickOptionRequest.Option[] options,
            Bundle extras) {
        if ((options.length != 2) ||
            !options[0].getLabel().toString().equals(Utils.PICKOPTON_1) ||
            !options[1].getLabel().toString().equals(Utils.PICKOPTON_2)) {
            Utils.addErrorResult(extras, "Pickoptions Not received correctly in Session.");
        } else {
            Log.i(TAG, "Pickoptions received ok from TestApp in Session");
        }
    }

    @Override
    public void onRequestPickOption(PickOptionRequest request) {
        Bundle extras = request.getExtras();
        CharSequence prompt = request.getVoicePrompt().getVoicePromptAt(0);
        Log.i(TAG, "in Session onRequestPickOption recvd. message=" +
                prompt + ", options = " + Utils.toOptionsString(request.getOptions()) +
                ", extras=" + Utils.toBundleString(extras));
        VoiceInteractor.PickOptionRequest.Option[] picked
            = new VoiceInteractor.PickOptionRequest.Option[1];
        assertPromptFromTestApp(prompt, extras);
        assertPickOptionsFromTestApp(request.getOptions(), extras);
        picked[0] = new VoiceInteractor.PickOptionRequest.Option(Utils.PICKOPTON_3, 0);
        AsyncTaskArg asyncTaskArg = new AsyncTaskArg().setRequest(request)
                .setExtras(extras)
                .setPickedOptions(picked);
        if (isTestTypeCancel(extras)) {
            Log.i(TAG, "in MainInteractionSession, Sending Cancel.");
            newTask().execute(
                    asyncTaskArg.setTestType(Utils.TestCaseType.PICKOPTION_REQUEST_CANCEL_TEST));
        } else {
            Log.i(TAG, "in MainInteractionSession sending sendPickOptionResult. " +
                    Utils.toBundleString(extras));
            newTask().execute(asyncTaskArg.setTestType(Utils.TestCaseType.PICKOPTION_REQUEST_TEST));
        }
    }

    public static final boolean isTestTypeCancel(Bundle extras) {
        Utils.TestCaseType testCaseType;
        try {
            testCaseType = Utils.TestCaseType.valueOf(extras.getString(Utils.TESTCASE_TYPE));
        } catch (IllegalArgumentException | NullPointerException e) {
            Log.wtf(TAG, "unexpected testCaseType value in Bundle received", e);
            return true;
        }
        return testCaseType == Utils.TestCaseType.COMPLETION_REQUEST_CANCEL_TEST ||
                testCaseType == Utils.TestCaseType.COMMANDREQUEST_CANCEL_TEST ||
                testCaseType == Utils.TestCaseType.CONFIRMATION_REQUEST_CANCEL_TEST ||
                testCaseType == Utils.TestCaseType.PICKOPTION_REQUEST_CANCEL_TEST ||
                testCaseType == Utils.TestCaseType.ABORT_REQUEST_CANCEL_TEST;
    }

    private class AsyncTaskArg {
        ConfirmationRequest confReq;
        CommandRequest commandReq;
        CompleteVoiceRequest compReq;
        AbortVoiceRequest abortReq;
        PickOptionRequest pickReq;
        Bundle extras;
        VoiceInteractor.PickOptionRequest.Option[] picked;
        Utils.TestCaseType testType;

        AsyncTaskArg setTestType(Utils.TestCaseType t) {testType = t; return this;}
        AsyncTaskArg setRequest(CommandRequest r) {commandReq = r; return this;}
        AsyncTaskArg setRequest(ConfirmationRequest r) {confReq = r; return this;}
        AsyncTaskArg setRequest(CompleteVoiceRequest r) {compReq = r; return this;}
        AsyncTaskArg setRequest(AbortVoiceRequest r) {abortReq = r; return this;}
        AsyncTaskArg setRequest(PickOptionRequest r) {pickReq = r; return this;}
        AsyncTaskArg setExtras(Bundle e) {extras = e;  return this;}
        AsyncTaskArg setPickedOptions(VoiceInteractor.PickOptionRequest.Option[] p) {
            picked = p;
            return this;
        }
    }

    private class MyTask extends AsyncTask<AsyncTaskArg, Void, Void> {
        @Override
        protected Void doInBackground(AsyncTaskArg... params) {
            AsyncTaskArg arg = params[0];
            Log.i(TAG, "in MyTask - doInBackground: requestType = " +
                    arg.testType.toString());
            switch (arg.testType) {
                case ABORT_REQUEST_CANCEL_TEST:
                    arg.abortReq.cancel();
                    break;
                case ABORT_REQUEST_TEST:
                    arg.abortReq.sendAbortResult(arg.extras);
                    break;
                case COMMANDREQUEST_CANCEL_TEST:
                    arg.commandReq.cancel();
                    break;
                case COMMANDREQUEST_TEST:
                    Log.i(TAG, "in MyTask sendResult. " +
                            Utils.toBundleString(arg.extras) + ", string_in_bundle: " +
                            Utils.TEST_ONCOMMAND_RESULT + " = " +
                            Utils.TEST_ONCOMMAND_RESULT_VALUE);
                    arg.commandReq.sendResult(arg.extras);
                    break;
                case COMPLETION_REQUEST_CANCEL_TEST:
                    arg.compReq.cancel();
                    break;
                case COMPLETION_REQUEST_TEST:
                    arg.compReq.sendCompleteResult(arg.extras);
                    break;
                case CONFIRMATION_REQUEST_CANCEL_TEST:
                     arg.confReq.cancel();
                     break;
                case CONFIRMATION_REQUEST_TEST:
                     arg.confReq.sendConfirmationResult(true, arg.extras);
                     break;
                case PICKOPTION_REQUEST_CANCEL_TEST:
                     arg.pickReq.cancel();
                     break;
                case PICKOPTION_REQUEST_TEST:
                     StringBuilder buf = new StringBuilder();
                     for (VoiceInteractor.PickOptionRequest.Option s : arg.picked) {
                         buf.append("option: " + s.toString() + ", ");
                     }
                     Log.i(TAG, "******** Sending PickoptionResult: " +
                             "picked: size = " + arg.picked.length +
                             ", Options = " + buf.toString() +
                             ", Bundle: " + Utils.toBundleString(arg.extras));
                     arg.pickReq.sendPickOptionResult(arg.picked, arg.extras);
                     break;
               default:
                   Log.i(TAG, "Doing nothing for the testcase type: " + arg.testType);
                   break;
            }
            return null;
        }
    }
}