org.robokind.api.speechrec.lifecycle.RemoteSpeechRecServiceLifecycle Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of org.robokind.api.speechrec Show documentation
The newest version!
/*
 * Copyright 2012 Hanson Robokind LLC.
 *
 * 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 org.robokind.api.speechrec.lifecycle;

import java.util.Map;
import java.util.Properties;
import org.jflux.api.messaging.rk.Constants;
import org.jflux.api.messaging.rk.MessageAsyncReceiver;
import org.jflux.api.messaging.rk.MessageSender;
import org.jflux.impl.services.rk.lifecycle.AbstractLifecycleProvider;
import org.jflux.impl.services.rk.lifecycle.utils.DescriptorListBuilder;
import org.robokind.api.messaging.services.ServiceCommand;
import org.robokind.api.messaging.services.ServiceCommandFactory;
import org.robokind.api.messaging.services.ServiceError;
import org.robokind.api.speechrec.SpeechRecEvent;
import org.robokind.api.speechrec.SpeechRecEventList;
import org.robokind.api.speechrec.SpeechRecService;
import org.robokind.api.speechrec.messaging.RemoteSpeechRecServiceClient;

/**
 *
 * @author Jason G. Pallack 
 */
public class RemoteSpeechRecServiceLifecycle extends 
        AbstractLifecycleProvider {
    private final static String theCommandSender = "commandSender";
    private final static String theConfigSender = "configSender";
    private final static String theErrorReceiver = "errorReceiver";   
    private final static String theCommandFactory = "commandFactory"; 
    private final static String theSpeechRecReceiver = "speechRecReceiver";
    private String myClientServiceId;
    private String myHostServiceId;
    private Class myConfigClass;
    
    /**
     * Creates a new SpeechTriggerHandlerLifecycle for a SpeechService
     * @param commandSenderId SpeechService to use
     */
    public RemoteSpeechRecServiceLifecycle(Class configClass,
            String speechRecServiceId, String remoteId,
            String commandSenderId, String configSenderId,
            String errorReceiverId, String requestSenderId,
            String eventsReceiverId){
        super(new DescriptorListBuilder()
                .dependency(theCommandSender, MessageSender.class)
                    .with(Constants.PROP_MESSAGE_SENDER_ID, commandSenderId)
                    .with(Constants.PROP_MESSAGE_TYPE, ServiceCommand.class.getName())
                .dependency(theConfigSender, MessageSender.class)
                    .with(Constants.PROP_MESSAGE_SENDER_ID, configSenderId)
                    .with(Constants.PROP_MESSAGE_TYPE, configClass.getName())
                .dependency(theErrorReceiver, MessageAsyncReceiver.class)
                    .with(Constants.PROP_MESSAGE_RECEIVER_ID, errorReceiverId)
                    .with(Constants.PROP_MESSAGE_TYPE, ServiceError.class.getName())
                .dependency(theSpeechRecReceiver, MessageAsyncReceiver.class)
                    .with(Constants.PROP_MESSAGE_RECEIVER_ID, eventsReceiverId)
                    .with(Constants.PROP_MESSAGE_TYPE, SpeechRecEventList.class.getName())
                .dependency(theCommandFactory, ServiceCommandFactory.class)
                .getDescriptors());
        if(speechRecServiceId == null || remoteId == null){
            throw new NullPointerException();
        }
        myClientServiceId = speechRecServiceId;
        myHostServiceId = remoteId;
        myRegistrationProperties = new Properties();
        myRegistrationProperties.put(
                SpeechRecService.PROP_ID, myClientServiceId);
    }

    @Override
    protected RemoteSpeechRecServiceClient create(Map services) {
        MessageSender commandSender = 
                (MessageSender)services.get(theCommandSender);
        MessageSender configSender = 
                (MessageSender)services.get(theConfigSender);
        MessageAsyncReceiver errorReceiver = 
                (MessageAsyncReceiver)services.get(theErrorReceiver);
        ServiceCommandFactory commandFactory = 
                (ServiceCommandFactory)services.get(theCommandFactory);
        MessageAsyncReceiver speechRecReceiver = 
                (MessageAsyncReceiver)services.get(theSpeechRecReceiver);
        return new RemoteSpeechRecServiceClient(
                myConfigClass, myClientServiceId, myHostServiceId, 
                commandSender, configSender, errorReceiver, 
                commandFactory, speechRecReceiver);
    }

    @Override
    protected void handleChange(String name, Object dependency, 
            Map availableDependencies){
        if(myService == null){
            return;
        }
        if(theCommandSender.equals(name)){
            myService.setCommandSender(
                    (MessageSender)dependency);
        }else if(theConfigSender.equals(name)){
            myService.setConfigSender((MessageSender)dependency);
        }else if(theErrorReceiver.equals(name)){
            myService.setErrorReceiver(
                    (MessageAsyncReceiver)dependency);
        }else if(theCommandFactory.equals(name)){
            myService.setCommandFactory((ServiceCommandFactory)dependency);
        }else if(theSpeechRecReceiver.equals(name)){
            myService.setSpeechRecReceiver(
                    (MessageAsyncReceiver)dependency);
        }
    }

    @Override
    public Class getServiceClass() {
        return SpeechRecService.class;
    }
}