エラー：このクラスは、apkを作成するときにデフォルトのコンストラクタ（...）[インスタンス化可能]を提供する必要があります

Question

私のアプリケーション用に署名付きapkを作成しようとしましたが、署名付きapkダイアログを作成した後、

エラー：このクラスは、デフォルトコンストラクタ（...）[インスタンス化]を提供しなければならない

public class MainActivity { 
    // Debugging 
    private static final String TAG = "BluetoothChatService"; 
    private static final boolean D = true; 

    // Name for the SDP record when creating server socket 
    private static final String NAME = "project"; 

    // Unique UUID for this application 
    private static final UUID MY_UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB"); 

    // Member fields 
    private final BluetoothAdapter mAdapter; 
    private final Handler mHandler; 
    private AcceptThread mAcceptThread; 
    private ConnectThread mConnectThread; 
    private ConnectedThread mConnectedThread; 

    private int mState; 

    // Constants that indicate the current connection state 
    public static final int STATE_NONE = 0;  // we're doing nothing 
    public static final int STATE_LISTEN = 1;  // now listening for incoming connections 
    public static final int STATE_CONNECTING = 2; // now initiating an outgoing connection 
    public static final int STATE_CONNECTED = 3; // now connected to a remote device 

    /** 
    * Constructor. Prepares a new BluetoothChat session. 
    * @param context The UI Activity Context 
    * @param handler A Handler to send messages back to the UI Activity 
    */ 
    public MainActivity(Context context, Handler handler) { 
     mAdapter = BluetoothAdapter.getDefaultAdapter(); 
     mState = STATE_NONE; 
     mHandler = handler; 
    } 

/** * チャット接続 * @param状態の現在の状態を設定し定義する整数現在の接続状態 */

/** 
* Return the current connection state. */ 
public synchronized int getState() { 
    return mState; 
} 

/** 
* Start the chat service. Specifically start AcceptThread to begin a 
* session in listening (server) mode. Called by the Activity onResume() */ 
public synchronized void start() { 
    if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;} 

    // Cancel any thread currently running a connection 
    if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;} 

    // Start the thread to listen on a BluetoothServerSocket 
    if (mAcceptThread == null) { 
     mAcceptThread = new AcceptThread(); 
     mAcceptThread.start(); 
    } 

    if (D) Log.d(TAG, "start"); 

    // Cancel any thread attempting to make a connection 
    if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;} 

    // Cancel any thread currently running a connection 
    if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;} 

    // Start the thread to listen on a BluetoothServerSocket 
    if (mAcceptThread == null) { 
     mAcceptThread = new AcceptThread(); 
     mAcceptThread.start(); 
    } 

} 

/** 
* Start the ConnectThread to initiate a connection to a remote device. 
* @param device The BluetoothDevice to connect 
*/ 
public synchronized void connect(BluetoothDevice device) { 
    if (D) Log.d(TAG, "connect to: " + device); 

    // Cancel any thread attempting to make a connection 
    if (mState == STATE_CONNECTING) { 
     if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;} 
    } 

    // Cancel any thread currently running a connection 
    if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;} 

    // Start the thread to connect with the given device 
    mConnectThread = new ConnectThread(device); 
    mConnectThread.start(); 

} 

/** 
* Start the ConnectedThread to begin managing a Bluetooth connection 
* @param socket The BluetoothSocket on which the connection was made 
* @param device The BluetoothDevice that has been connected 
*/ 
public synchronized void connected(BluetoothSocket socket, BluetoothDevice device) { 
    if (D) Log.d(TAG, "connected"); 

    // Cancel the thread that completed the connection 
    if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;} 

    // Cancel any thread currently running a connection 
    if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;} 

    // Cancel the accept thread because we only want to connect to one device 
    if (mAcceptThread != null) {mAcceptThread.cancel(); mAcceptThread = null;} 

    // Start the thread to manage the connection and perform transmissions 
    mConnectedThread = new ConnectedThread(socket); 
    mConnectedThread.start(); 

    // Send the name of the connected device back to the UI Activity 
    Message msg = mHandler.obtainMessage(hotlifebluetoothspp.MESSAGE_DEVICE_NAME); 
    Bundle bundle = new Bundle(); 
    bundle.putString(hotlifebluetoothspp.DEVICE_NAME, device.getName()); 
    msg.setData(bundle); 
    mHandler.sendMessage(msg); 


} 

/** 
* Stop all threads 
*/ 
public synchronized void stop() { 
    if (D) Log.d(TAG, "stop"); 
    if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;} 
    if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;} 
    if (mAcceptThread != null) {mAcceptThread.cancel(); mAcceptThread = null;} 

} 

/** 
* Write to the ConnectedThread in an unsynchronized manner 
* @param out The bytes to write 
* @see ConnectedThread#write(byte[]) 
*/ 
public void write(byte[] out) { 
    // Create temporary object 
    ConnectedThread r; 
    // Synchronize a copy of the ConnectedThread 
    synchronized (this) { 
     if (mState != STATE_CONNECTED) return; 
     r = mConnectedThread; 
    } 
    // Perform the write unsynchronized 
    r.write(out); 
} 

/** 
* Indicate that the connection attempt failed and notify the UI Activity. 
*/ 


/** 
* Indicate that the connection was lost and notify the UI Activity. 
*/ 
private void connectionLost() { 

    // Send a failure message back to the Activity 
    Message msg = mHandler.obtainMessage(hotlifebluetoothspp.MESSAGE_TOAST); 
    Bundle bundle = new Bundle(); 
    bundle.putString(hotlifebluetoothspp.TOAST, "Device connection was lost"); 
    msg.setData(bundle); 
    mHandler.sendMessage(msg); 
} 

/** 
* This thread runs while listening for incoming connections. It behaves 
* like a server-side client. It runs until a connection is accepted 
* (or until cancelled). 
*/ 
private class AcceptThread extends Thread { 
    // The local server socket 
    private final BluetoothServerSocket mmServerSocket; 

    public AcceptThread() { 

     BluetoothServerSocket tmp = null; 

     // Create a new listening server socket 
     try { 
      tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID); 
     } catch (IOException e) { 
      Log.e(TAG, "listen() failed", e); 
     } 
     mmServerSocket = tmp; 
    } 

    public void run() { 
     if (D) Log.d(TAG, "BEGIN mAcceptThread" + this); 
     setName("AcceptThread"); 
     BluetoothSocket socket = null; 

     // Listen to the server socket if we're not connected 
     while (mState != STATE_CONNECTED) { 
      try { 
       // This is a blocking call and will only return on a 
       // successful connection or an exception 
       socket = mmServerSocket.accept(); 
      } catch (IOException e) { 
       Log.e(TAG, "accept() failed", e); 
       break; 
      } 

      // If a connection was accepted 
      if (socket != null) { 
       synchronized (MainActivity.this) { 
        switch (mState) { 
         case STATE_LISTEN: 
         case STATE_CONNECTING: 
          // Situation normal. Start the connected thread. 
          connected(socket, socket.getRemoteDevice()); 
          break; 
         case STATE_NONE: 
         case STATE_CONNECTED: 
          // Either not ready or already connected. Terminate new socket. 
          try { 
           socket.close(); 
          } catch (IOException e) { 
           Log.e(TAG, "Could not close unwanted socket", e); 
          } 
          break; 
        } 
       } 
      } 
     } 
     if (D) Log.i(TAG, "END mAcceptThread"); 
    } 

    public void cancel() { 
     if (D) Log.d(TAG, "cancel " + this); 
     try { 
      mmServerSocket.close(); 
     } catch (IOException e) { 
      Log.e(TAG, "close() of server failed", e); 
     } 
    } 
} 


/** 
* This thread runs while attempting to make an outgoing connection 
* with a device. It runs straight through; the connection either 
* succeeds or fails. 
*/ 
private class ConnectThread extends Thread { 
    private final BluetoothSocket mmSocket; 
    private final BluetoothDevice mmDevice; 

    public ConnectThread(BluetoothDevice device) { 
     mmDevice = device; 
     BluetoothSocket tmp = null; 

     // Get a BluetoothSocket for a connection with the 
     // given BluetoothDevice 
     try { 
      tmp = device.createRfcommSocketToServiceRecord(MY_UUID); 
     } catch (IOException e) { 
      Log.e(TAG, "create() failed", e); 
     } 
     mmSocket = tmp; 
    } 



    public void cancel() { 
     try { 
      mmSocket.close(); 
     } catch (IOException e) { 
      Log.e(TAG, "close() of connect socket failed", e); 
     } 
    } 

    public BluetoothDevice getMmDevice() { 
     return mmDevice; 
    } 
} 

/** 
* This thread runs during a connection with a remote device. 
* It handles all incoming and outgoing transmissions. 
*/ 
private class ConnectedThread extends Thread { 
    private final BluetoothSocket mmSocket; 
    private final InputStream mmInStream; 
    private final OutputStream mmOutStream; 

    public ConnectedThread(BluetoothSocket socket) { 
     Log.d(TAG, "create ConnectedThread"); 
     mmSocket = socket; 
     InputStream tmpIn = null; 
     OutputStream tmpOut = null; 

     // Get the BluetoothSocket input and output streams 
     try { 
      tmpIn = socket.getInputStream(); 
      tmpOut = socket.getOutputStream(); 
     } catch (IOException e) { 
      Log.e(TAG, "temp sockets not created", e); 
     } 

     mmInStream = tmpIn; 
     mmOutStream = tmpOut; 
    } 

    public void run() { 
     Log.i(TAG, "BEGIN mConnectedThread"); 
     byte[] buffer = new byte[1024]; 
     int bytes; 

     // Keep listening to the InputStream while connected 
     while (true) { 
      try { 
       // Read from the InputStream 
       bytes = mmInStream.read(buffer); 

       // Send the obtained bytes to the UI Activity 
       mHandler.obtainMessage(hotlifebluetoothspp.MESSAGE_READ, bytes, -1, buffer) 
         .sendToTarget(); 
      } catch (IOException e) { 
       Log.e(TAG, "disconnected", e); 
       connectionLost(); 
       break; 
      } 
     } 
    } 

    /** 
    * Write to the connected OutStream. 
    * @param buffer The bytes to write 
    */ 
    public void write(byte[] buffer) { 
     try { 
      mmOutStream.write(buffer); 

      // Share the sent message back to the UI Activity 
      mHandler.obtainMessage(hotlifebluetoothspp.MESSAGE_WRITE, -1, -1, buffer) 
        .sendToTarget(); 
     } catch (IOException e) { 
      Log.e(TAG, "Exception during write", e); 
     } 
    } 

    public void cancel() { 
     try { 
      mmSocket.close(); 
     } catch (IOException e) { 
      Log.e(TAG, "close() of connect socket failed", e); 
     } 
    } 
} 

}

Answer 1

私はあなたが定義されたコンストラクタを削除し、onCreate()方法の間、すべての初期化を行うことをお勧めします。

この削除：今、私はあなたのクラスがActivityのサブクラスではないことがわかり

@Override 
protected void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    mAdapter = BluetoothAdapter.getDefaultAdapter(); 
    mState = STATE_NONE; 
    mHandler = handler; 
} 

UPDATE

エリクソン

：

public MainActivity(Context context, Handler handler) { 
    mAdapter = BluetoothAdapter.getDefaultAdapter(); 
    mState = STATE_NONE; 
    mHandler = handler; 
} 

をそして、これを追加します。したがって、MainActivityは実際にはActivityではありません。私の提案はあなたのためには機能しません。

通常、我々は次のようActivityのサブクラスとしてMainActvityを使用します。それはあなたのプロジェクト/コードについての詳細はせずに、あなたの意思を伝えるのは難しいです

public MainActivity extends Activity { 
} 

。 質問を更新してください。

MainActivityが本当に正しいか、あなたは本当に多分、extendsActivityにしたくない場合は、右の修正は、単に以下の行を追加することになります。

public MainActivity() { 
} 

Answer 2

this class should provide a default constructor (…) [Instantiatable]

デフォルトコンストラクタを追加しようとしましたか？

public MainActivity() { 

}