i am unable to start rabbitmq service on android
===

my logcat is

    07-28 13:59:31.107: I/global(372): Default buffer size used in BufferedInputStream     constructor. It would be better to be explicit if an 8k buffer is required.
    07-28 13:59:31.107: I/global(372): Default buffer size used in BufferedOutputStream constructor. It would be better to be explicit if an 8k buffer is required.
    07-28 13:59:38.222: W/ActivityManager(58): Launch timeout has expired, giving up wake lock!
    07-28 13:59:38.632: W/ActivityManager(58): Activity idle timeout for HistoryRecord{44ebbc30 com.shrey.connec/.androidconn}
    07-28 13:59:43.708: D/dalvikvm(117): GC_EXPLICIT freed 820 objects / 45864 bytes in 71ms
    07-28 13:59:48.708: D/dalvikvm(218): GC_EXPLICIT freed 100 objects / 4056 bytes in 65ms
     07-28 13:59:53.708: D/dalvikvm(259): GC_EXPLICIT freed 6 objects / 176 bytes in 70ms
     07-28 13:59:54.958: I/ActivityManager(58): Displayed activity com.shrey.connec/.androidconn: 26738 ms (total 26738 ms)
and my code is 
        public abstract class rabbitmq {
		      public String mServer;
		      public String mExchange;
		 
		      protected Channel mModel = null;
		      protected Connection  mConnection;
		 
		      protected boolean Running ;
		 
		      protected  String MyExchangeType ;
		 
		      /**
		       *
		       * @param server The server address
		       * @param exchange The named exchange
		       * @param exchangeType The exchange type name
		       */
		      public rabbitmq(String server, String exchange, String exchangeType)
		      {
		          mServer = server;
		          mExchange = exchange;
		          MyExchangeType = exchangeType;
		      }
		 
		      public void Dispose()
		      {
		          Running = false;
		 
		            try {
		                if (mConnection!=null)
		                    mConnection.close();
		                if (mModel != null)
		                    mModel.abort();
		            } catch (IOException e) {
		                // TODO Auto-generated catch block
		                e.printStackTrace();
		            }
		 
		      }
		 
		      /**
		       * Connect to the broker and create the exchange
		       * @return success
		       */
		      public boolean connectToRabbitMQ()
		      {
		          if(mModel!= null && mModel.isOpen() )//already declared
		              return true;
		          try
		          {
		              ConnectionFactory connectionFactory = new ConnectionFactory();
		              connectionFactory.setHost(mServer);
		              mConnection = connectionFactory.newConnection();
		              mModel = mConnection.createChannel();
		              mModel.exchangeDeclare(mExchange, MyExchangeType, true);
		 
		              return true;
		          }
		          catch (Exception e)
		          {
		              e.printStackTrace();
		              return false;
		          }
		      }
		}
 rabbitmqclient is

    public class rabbitmqclient extends rabbitmq {

	public rabbitmqclient(String server, String exchange, String exchangeType) {

		super(server, exchange, exchangeType);
	}

	// The Queue name for this consumer
	private String mQueue;
	private QueueingConsumer MySubscription;

	// last message to post back
	private byte[] mLastMessage;

	// An interface to be implemented by an object that is interested in
	// messages(listener)
	public interface OnReceiveMessageHandler {
		public void onReceiveMessage(byte[] message);
	};

	// A reference to the listener, we can only have one at a time(for now)
	private OnReceiveMessageHandler mOnReceiveMessageHandler;

	/**
	 * 
	 * Set the callback for received messages
	 * 
	 * @param handler
	 *            The callback
	 */
	public void setOnReceiveMessageHandler(OnReceiveMessageHandler handler) {
		mOnReceiveMessageHandler = handler;
	};

	private Handler mMessageHandler = new Handler();
	private Handler mConsumeHandler = new Handler();

	// Create runnable for posting back to main thread
	final Runnable mReturnMessage = new Runnable() {
		public void run() {
			mOnReceiveMessageHandler.onReceiveMessage(mLastMessage);
		}
	};

	final Runnable mConsumeRunner = new Runnable() {
		public void run() {
			Consume();
		}
	};

	/**
	 * Create Exchange and then start consuming. A binding needs to be added
	 * before any messages will be delivered
	 */
	@Override
	public boolean connectToRabbitMQ() {
		if (super.connectToRabbitMQ()) {

			try {
				mQueue = mModel.queueDeclare().getQueue();
				MySubscription = new QueueingConsumer(mModel);
				mModel.basicConsume(mQueue, false, MySubscription);
			} catch (IOException e) {
				e.printStackTrace();
				return false;
			}
			if (MyExchangeType == "fanout")
				AddBinding("");// fanout has default binding

			Running = true;
			mConsumeHandler.post(mConsumeRunner);

			return true;
		}
		return false;
	}

	/**
	 * Add a binding between this consumers Queue and the Exchange with
	 * routingKey
	 * 
	 * @param routingKey
	 *            the binding key eg GOOG
	 */
	 public void AddBinding(String routingKey) {
		try {
			mModel.queueBind(mQueue, mExchange, routingKey);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	/**
	 * Remove binding between this consumers Queue and the Exchange with
	 * routingKey
	 * 
	 * @param routingKey
	 *            the binding key eg GOOG
	 */
	public void RemoveBinding(String routingKey) {
		try {
			mModel.queueUnbind(mQueue, mExchange, routingKey);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	private void Consume() {
		Thread thread = new Thread() {

			@Override
			public void run() {
				while (Running) {
					QueueingConsumer.Delivery delivery;
					try {
						delivery = MySubscription.nextDelivery();
						mLastMessage = delivery.getBody();
						mMessageHandler.post(mReturnMessage);
						try {
							mModel.basicAck(delivery.getEnvelope()
									.getDeliveryTag(), false);
						} catch (IOException e) {
							e.printStackTrace();
						}
					} catch (InterruptedException ie) {
						ie.printStackTrace();
					}
				}
			}
		};
		thread.start();

	}

	public void dispose() {
		Running = false;
	}
     }
and activity code is

       public class androidconn extends Activity {
	    private rabbitmqclient mConsumer;
	    private TextView mOutput;
	 
	    /** Called when the activity is first created. */
	    @Override
	    public void onCreate(Bundle savedInstanceState) {
	        super.onCreate(savedInstanceState);
	        setContentView(R.layout.activity_main);
	 
	        //The output TextView we'll use to display messages
	        mOutput =  (TextView) findViewById(R.id.moutput);
	 
	        //Create the consumer
	        mConsumer = new rabbitmqclient("115.245.143.22  :5672",
	                "logs",
	                "fanout");
	 
	        //Connect to broker
	        mConsumer.connectToRabbitMQ();
	 
	        //register for messages
	        mConsumer.setOnReceiveMessageHandler(new OnReceiveMessageHandler(){
	 
	            public void onReceiveMessage(byte[] message) {
	                String text = "";
	                try {
	                    text = new String(message, "UTF");
	                } catch (UnsupportedEncodingException e) {
	                    e.printStackTrace();
	                }
	 
	                mOutput.append("\n"+text);
	            }
	        });
	 
	    }
	 
	    @Override
	    protected void onResume() {
	        super.onPause();
	        mConsumer.connectToRabbitMQ();
	    }
	 
	    @Override
	    protected void onPause() {
	        super.onPause();
	        mConsumer.dispose();
	    }
	}
and the messanger code is from which i am wishing to send the message

     public class rabbitchat {

    private final static String QUEUE_NAME = "hello";

    public static void main(String[] argv)
        throws java.io.IOException,
             java.lang.InterruptedException {

      ConnectionFactory factory = new ConnectionFactory();
      factory.setHost("115.245.143.22 ");
     factory.setPort(5672);
    Connection connection = factory.newConnection();
    Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
     String message = "Hello World!";
    channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
    System.out.println(" [x] Sent '" + message + "'");
    channel.close();
     connection.close();
 
    }
    }
in both messanger and android i am using same ip that is of my computer but still i am unable to send message kindly help me out in this