jurt/com/sun/star/lib/connections/pipe/PipeConnection.java

   1 /*
   2  * This file is part of the LibreOffice project.
   3  *
   4  * This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   7  *
   8  * This file incorporates work covered by the following license notice:
   9  *
  10  *   Licensed to the Apache Software Foundation (ASF) under one or more
  11  *   contributor license agreements. See the NOTICE file distributed
  12  *   with this work for additional information regarding copyright
  13  *   ownership. The ASF licenses this file to you under the Apache
  14  *   License, Version 2.0 (the "License"); you may not use this file
  15  *   except in compliance with the License. You may obtain a copy of
  16  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  17  */
  18 package com.sun.star.lib.connections.pipe;
  19
  20 import java.io.IOException;
  21 import java.util.ArrayList;
  22 import java.util.StringTokenizer;
  23
  24 import com.sun.star.connection.XConnection;
  25 import com.sun.star.connection.XConnectionBroadcaster;
  26 import com.sun.star.io.XStreamListener;
  27 import com.sun.star.lib.util.NativeLibraryLoader;
  28
  29 /**
  30  * The PipeConnection implements the <code>XConnection</code> interface
  31  * and is uses by the <code>PipeConnector</code> and the <code>PipeAcceptor</code>.
  32  * This class is not part of the provided <code>api</code>.
  33  *
  34  * @see         com.sun.star.lib.connections.pipe.pipeAcceptor
  35  * @see         com.sun.star.lib.connections.pipe.pipeConnector
  36  * @see         com.sun.star.connection.XConnection
  37  * @since       UDK1.0
  38  */
  39 public class PipeConnection implements XConnection, XConnectionBroadcaster {
  40     /**
  41      * When set to true, enables various debugging output.
  42      */
  43     static public final boolean DEBUG = false;
  44
  45     static {
  46         // load shared library for JNI code
  47         NativeLibraryLoader.loadLibrary(PipeConnection.class.getClassLoader(), "jpipe");
  48     }
  49
  50     protected String    _aDescription;
  51     protected long      _nPipeHandle;
  52     protected ArrayList<XStreamListener>    _aListeners;
  53     protected boolean   _bFirstRead;
  54
  55     /**
  56      * Constructs a new <code>PipeConnection</code>.
  57      *
  58      * @param  description   the description of the connection.
  59      */
  60     public PipeConnection(String description)
  61         throws IOException
  62     {
  63         if (DEBUG) System.err.println("##### " + getClass().getName() + " - instantiated " + description );
  64
  65         _aListeners = new ArrayList<XStreamListener>();
  66         _bFirstRead = true;
  67
  68         // get pipe name from pipe descriptor
  69         String aPipeName  ;
  70         StringTokenizer aTokenizer = new StringTokenizer( description, "," );
  71         if ( aTokenizer.hasMoreTokens() ) {
  72             String aConnType = aTokenizer.nextToken();
  73             if ( !aConnType.equals( "pipe" ) )
  74                 throw new RuntimeException( "invalid pipe descriptor: does not start with 'pipe,'" );
  75
  76             String aPipeNameParam = aTokenizer.nextToken();
  77             if ( !aPipeNameParam.substring( 0, 5 ).equals( "name=" ) )
  78                 throw new RuntimeException( "invalid pipe descriptor: no 'name=' parameter found" );
  79             aPipeName = aPipeNameParam.substring( 5 );
  80         }
  81         else
  82             throw new RuntimeException( "invalid or empty pipe descriptor" );
  83
  84         // create the pipe
  85         try {
  86             createJNI( aPipeName );
  87         } catch ( java.lang.Exception ex1 ) {
  88             IOException ex2 = new IOException();
  89             ex2.initCause(ex1);
  90             throw ex2;
  91         }
  92     }
  93
  94     public void addStreamListener(XStreamListener aListener ) throws com.sun.star.uno.RuntimeException {
  95         _aListeners.add(aListener);
  96     }
  97
  98     public void removeStreamListener(XStreamListener aListener ) throws com.sun.star.uno.RuntimeException {
  99         _aListeners.remove(aListener);
 100     }
 101
 102     private void notifyListeners_open() {
 103         for (XStreamListener xStreamListener : _aListeners) {
 104             xStreamListener.started();
 105         }
 106     }
 107
 108     private void notifyListeners_close() {
 109         for (XStreamListener xStreamListener : _aListeners) {
 110             xStreamListener.closed();
 111         }
 112     }
 113
 114     private void notifyListeners_error(com.sun.star.uno.Exception exception) {
 115         for (XStreamListener xStreamListener : _aListeners) {
 116             xStreamListener.error(exception);
 117         }
 118     }
 119
 120     // JNI implementation to create the pipe
 121     private native int createJNI( String name )
 122         throws com.sun.star.io.IOException, com.sun.star.uno.RuntimeException;
 123
 124     // JNI implementation to read from the pipe
 125     private native int readJNI(/*OUT*/byte[][] bytes, int nBytesToRead)
 126         throws com.sun.star.io.IOException, com.sun.star.uno.RuntimeException;
 127
 128     // JNI implementation to write to the pipe
 129     private native void writeJNI(byte aData[])
 130         throws com.sun.star.io.IOException, com.sun.star.uno.RuntimeException;
 131
 132     // JNI implementation to flush the pipe
 133     private native void flushJNI()
 134         throws com.sun.star.io.IOException, com.sun.star.uno.RuntimeException;
 135
 136     // JNI implementation to close the pipe
 137     private native void closeJNI()
 138         throws com.sun.star.io.IOException, com.sun.star.uno.RuntimeException;
 139
 140     /**
 141      * Read the required number of bytes.
 142      *
 143      * @param    bytes   the outparameter, where the bytes have to be placed.
 144      * @param    nBytesToRead the number of bytes to read.
 145      * @return   the number of bytes read.
 146      *
 147      * @see      com.sun.star.connection.XConnection#read
 148      */
 149     public int read(/*OUT*/byte[][] bytes, int nBytesToRead)
 150         throws com.sun.star.io.IOException, com.sun.star.uno.RuntimeException
 151     {
 152         if(_bFirstRead) {
 153             _bFirstRead = false;
 154
 155             notifyListeners_open();
 156         }
 157
 158         return readJNI( bytes, nBytesToRead );
 159     }
 160
 161     /**
 162      * Write bytes.
 163      *
 164      * @param    aData the bytes to write.
 165      * @see      com.sun.star.connection.XConnection#write
 166      */
 167     public void write(byte aData[])
 168         throws com.sun.star.io.IOException, com.sun.star.uno.RuntimeException
 169     {
 170         writeJNI( aData );
 171     }
 172
 173     /**
 174      * Flushes the buffer.
 175      *
 176      * @see      com.sun.star.connection.XConnection#flush
 177      */
 178     public void flush()
 179         throws com.sun.star.io.IOException, com.sun.star.uno.RuntimeException
 180     {
 181         flushJNI();
 182     }
 183
 184     /**
 185      * Closes the connection.
 186      *
 187      * @see       com.sun.star.connection.XConnection#close
 188      */
 189     public void close()
 190         throws com.sun.star.io.IOException, com.sun.star.uno.RuntimeException
 191     {
 192         if (DEBUG) System.out.print( "PipeConnection::close() " );
 193         closeJNI();
 194         notifyListeners_close();
 195         if (DEBUG) System.out.println( "done" );
 196     }
 197
 198     /**
 199      * Gives a description of the connection.
 200      *
 201      * @return  the description.
 202      * @see     com.sun.star.connection.XConnection#getDescription
 203      */
 204     public String getDescription() throws com.sun.star.uno.RuntimeException {
 205         return _aDescription;
 206     }
 207
 208 }