bug #2519304: more verbose logs for sending a MMS. Capture the payload size and mmsc...
[0xdroid:packages_apps_mms.git] / src / com / android / mms / transaction / Transaction.java
1 /*
2  * Copyright (C) 2007-2008 Esmertec AG.
3  * Copyright (C) 2007-2008 The Android Open Source Project
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  *      http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17
18 package com.android.mms.transaction;
19
20 import com.android.mms.util.SendingProgressTokenManager;
21 import com.android.mms.LogTag;
22
23 import android.content.Context;
24 import android.net.Uri;
25 import android.net.NetworkUtils;
26 import android.net.ConnectivityManager;
27 import android.util.Log;
28
29 import java.io.IOException;
30
31 /**
32  * Transaction is an abstract class for notification transaction, send transaction
33  * and other transactions described in MMS spec.
34  * It provides the interfaces of them and some common methods for them.
35  */
36 public abstract class Transaction extends Observable {
37     private final int mServiceId;
38
39     protected Context mContext;
40     protected String mId;
41     protected TransactionState mTransactionState;
42     protected TransactionSettings mTransactionSettings;
43
44     /**
45      * Identifies push requests.
46      */
47     public static final int NOTIFICATION_TRANSACTION = 0;
48     /**
49      * Identifies deferred retrieve requests.
50      */
51     public static final int RETRIEVE_TRANSACTION     = 1;
52     /**
53      * Identifies send multimedia message requests.
54      */
55     public static final int SEND_TRANSACTION         = 2;
56     /**
57      * Identifies send read report requests.
58      */
59     public static final int READREC_TRANSACTION      = 3;
60
61     public Transaction(Context context, int serviceId,
62             TransactionSettings settings) {
63         mContext = context;
64         mTransactionState = new TransactionState();
65         mServiceId = serviceId;
66         mTransactionSettings = settings;
67     }
68
69     /**
70      * Returns the transaction state of this transaction.
71      *
72      * @return Current state of the Transaction.
73      */
74     @Override
75     public TransactionState getState() {
76         return mTransactionState;
77     }
78
79     /**
80      * An instance of Transaction encapsulates the actions required
81      * during a MMS Client transaction.
82      */
83     public abstract void process();
84
85     /**
86      * Used to determine whether a transaction is equivalent to this instance.
87      *
88      * @param transaction the transaction which is compared to this instance.
89      * @return true if transaction is equivalent to this instance, false otherwise.
90      */
91     public boolean isEquivalent(Transaction transaction) {
92         return getClass().equals(transaction.getClass())
93                 && mId.equals(transaction.mId);
94     }
95
96     /**
97      * Get the service-id of this transaction which was assigned by the framework.
98      * @return the service-id of the transaction
99      */
100     public int getServiceId() {
101         return mServiceId;
102     }
103
104     public TransactionSettings getConnectionSettings() {
105         return mTransactionSettings;
106     }
107     public void setConnectionSettings(TransactionSettings settings) {
108         mTransactionSettings = settings;
109     }
110
111     /**
112      * A common method to send a PDU to MMSC.
113      *
114      * @param pdu A byte array which contains the data of the PDU.
115      * @return A byte array which contains the response data.
116      *         If an HTTP error code is returned, an IOException will be thrown.
117      * @throws IOException if any error occurred on network interface or
118      *         an HTTP error code(>=400) returned from the server.
119      */
120     protected byte[] sendPdu(byte[] pdu) throws IOException {
121         return sendPdu(SendingProgressTokenManager.NO_TOKEN, pdu,
122                 mTransactionSettings.getMmscUrl());
123     }
124
125     /**
126      * A common method to send a PDU to MMSC.
127      *
128      * @param pdu A byte array which contains the data of the PDU.
129      * @param mmscUrl Url of the recipient MMSC.
130      * @return A byte array which contains the response data.
131      *         If an HTTP error code is returned, an IOException will be thrown.
132      * @throws IOException if any error occurred on network interface or
133      *         an HTTP error code(>=400) returned from the server.
134      */
135     protected byte[] sendPdu(byte[] pdu, String mmscUrl) throws IOException {
136         return sendPdu(SendingProgressTokenManager.NO_TOKEN, pdu, mmscUrl);
137     }
138
139     /**
140      * A common method to send a PDU to MMSC.
141      *
142      * @param token The token to identify the sending progress.
143      * @param pdu A byte array which contains the data of the PDU.
144      * @return A byte array which contains the response data.
145      *         If an HTTP error code is returned, an IOException will be thrown.
146      * @throws IOException if any error occurred on network interface or
147      *         an HTTP error code(>=400) returned from the server.
148      */
149     protected byte[] sendPdu(long token, byte[] pdu) throws IOException {
150         String mmscUrl = mTransactionSettings.getMmscUrl();
151
152         if (Log.isLoggable(LogTag.TRANSACTION, Log.VERBOSE)) {
153             Log.d(LogTag.TRANSACTION, "Transaction.sendPdu: mmscUrl=" + mmscUrl +
154                     ", token=" + token + ", payload_size=" + (pdu != null ? pdu.length : 0));
155         }
156         return sendPdu(token, pdu, mmscUrl);
157     }
158
159     /**
160      * A common method to send a PDU to MMSC.
161      *
162      * @param token The token to identify the sending progress.
163      * @param pdu A byte array which contains the data of the PDU.
164      * @param mmscUrl Url of the recipient MMSC.
165      * @return A byte array which contains the response data.
166      *         If an HTTP error code is returned, an IOException will be thrown.
167      * @throws IOException if any error occurred on network interface or
168      *         an HTTP error code(>=400) returned from the server.
169      */
170     protected byte[] sendPdu(long token, byte[] pdu, String mmscUrl) throws IOException {
171         ensureRouteToHost(mmscUrl, mTransactionSettings);
172         return HttpUtils.httpConnection(
173                 mContext, token,
174                 mmscUrl,
175                 pdu, HttpUtils.HTTP_POST_METHOD,
176                 mTransactionSettings.isProxySet(),
177                 mTransactionSettings.getProxyAddress(),
178                 mTransactionSettings.getProxyPort());
179     }
180
181     /**
182      * A common method to retrieve a PDU from MMSC.
183      *
184      * @param url The URL of the message which we are going to retrieve.
185      * @return A byte array which contains the data of the PDU.
186      *         If the status code is not correct, an IOException will be thrown.
187      * @throws IOException if any error occurred on network interface or
188      *         an HTTP error code(>=400) returned from the server.
189      */
190     protected byte[] getPdu(String url) throws IOException {
191         ensureRouteToHost(url, mTransactionSettings);
192         return HttpUtils.httpConnection(
193                 mContext, SendingProgressTokenManager.NO_TOKEN,
194                 url, null, HttpUtils.HTTP_GET_METHOD,
195                 mTransactionSettings.isProxySet(),
196                 mTransactionSettings.getProxyAddress(),
197                 mTransactionSettings.getProxyPort());
198     }
199
200     /**
201      * Make sure that a network route exists to allow us to reach the host in the
202      * supplied URL, and to the MMS proxy host as well, if a proxy is used.
203      * @param url The URL of the MMSC to which we need a route
204      * @param settings Specifies the address of the proxy host, if any
205      * @throws IOException if the host doesn't exist, or adding the route fails.
206      */
207     private void ensureRouteToHost(String url, TransactionSettings settings) throws IOException {
208         ConnectivityManager connMgr =
209                 (ConnectivityManager) mContext.getSystemService(Context.CONNECTIVITY_SERVICE);
210
211         int inetAddr;
212         if (settings.isProxySet()) {
213             String proxyAddr = settings.getProxyAddress();
214             inetAddr = NetworkUtils.lookupHost(proxyAddr);
215             if (inetAddr == -1) {
216                 throw new IOException("Cannot establish route for " + url + ": Unknown host");
217             } else {
218                 if (!connMgr.requestRouteToHost(
219                         ConnectivityManager.TYPE_MOBILE_MMS, inetAddr)) {
220                     throw new IOException("Cannot establish route to proxy " + inetAddr);
221                 }
222             }
223         } else {
224             Uri uri = Uri.parse(url);
225             inetAddr = NetworkUtils.lookupHost(uri.getHost());
226             if (inetAddr == -1) {
227                 throw new IOException("Cannot establish route for " + url + ": Unknown host");
228             } else {
229                 if (!connMgr.requestRouteToHost(
230                         ConnectivityManager.TYPE_MOBILE_MMS, inetAddr)) {
231                     throw new IOException("Cannot establish route to " + inetAddr + " for " + url);
232                 }
233             }
234         }
235     }
236
237     @Override
238     public String toString() {
239         return getClass().getName() + ": serviceId=" + mServiceId;
240     }
241
242     /**
243      * Get the type of the transaction.
244      *
245      * @return Transaction type in integer.
246      */
247     abstract public int getType();
248 }