1/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.cellbroadcastreceiver.tests;
18
19import android.app.Activity;
20import android.os.Bundle;
21import android.os.Handler;
22import android.os.Message;
23import android.util.Log;
24import android.view.View;
25import android.view.View.OnClickListener;
26import android.widget.Button;
27import android.widget.CheckBox;
28import android.widget.EditText;
29
30import java.util.Random;
31
32/**
33 * Activity to send test cell broadcast messages from GUI.
34 */
35public class SendTestBroadcastActivity extends Activity {
36    private static final String TAG = "SendTestBroadcastActivity";
37
38    /** Whether to delay before sending test message. */
39    private boolean mDelayBeforeSending;
40
41    /** Delay time before sending test message (when box is checked). */
42    private static final int DELAY_BEFORE_SENDING_MSEC = 5000;
43
44    private final Handler mDelayHandler = new Handler() {
45        @Override
46        public void handleMessage(Message msg) {
47            // call the onClick() method again, passing null View.
48            // The callback will ignore mDelayBeforeSending when the View is null.
49            OnClickListener pendingButtonClick = (OnClickListener) msg.obj;
50            pendingButtonClick.onClick(null);
51        }
52    };
53
54    /**
55     * Increment the message ID field and return the previous value.
56     * @return the current value of the message ID text field
57     */
58    private int getMessageId() {
59        EditText messageIdField = (EditText) findViewById(R.id.message_id);
60        int messageId = 0;
61        try {
62            messageId = Integer.parseInt(messageIdField.getText().toString());
63        } catch (NumberFormatException ignored) {
64            Log.e(TAG, "Invalid message ID");
65        }
66        int newMessageId = (messageId + 1) % 65536;
67        if (newMessageId == 0) {
68            newMessageId = 1;
69        }
70        messageIdField.setText(String.valueOf(newMessageId));
71        return messageId;
72    }
73
74    /**
75     * Return the value of the category field.
76     * @return the current value of the category text field
77     */
78    private int getCategory() {
79        EditText categoryField = (EditText) findViewById(R.id.category_id);
80        return Integer.parseInt(categoryField.getText().toString());
81    }
82
83    /**
84     * Initialization of the Activity after it is first created.  Must at least
85     * call {@link android.app.Activity#setContentView(int)} to
86     * describe what is to be displayed in the screen.
87     */
88    @Override
89    protected void onCreate(Bundle savedInstanceState) {
90        super.onCreate(savedInstanceState);
91
92        setContentView(R.layout.test_buttons);
93
94        /* Set message ID to a random value from 1-65535. */
95        EditText messageIdField = (EditText) findViewById(R.id.message_id);
96        messageIdField.setText(String.valueOf(new Random().nextInt(65535) + 1));
97
98        /* When category ID is non-zero, use it for the GSM/UMTS message identifier. */
99        EditText categoryIdField = (EditText) findViewById(R.id.category_id);
100        categoryIdField.setText("0");
101
102        /* Send an ETWS normal broadcast message to app. */
103        Button etwsNormalTypeButton = (Button) findViewById(R.id.button_etws_normal_type);
104        etwsNormalTypeButton.setOnClickListener(new OnClickListener() {
105            public void onClick(View v) {
106                if (mDelayBeforeSending && v != null) {
107                    Message msg = mDelayHandler.obtainMessage(0, this);
108                    mDelayHandler.sendMessageDelayed(msg, DELAY_BEFORE_SENDING_MSEC);
109                } else {
110                    SendTestMessages.testSendEtwsMessageNormal(SendTestBroadcastActivity.this,
111                            getMessageId());
112                }
113            }
114        });
115
116        /* Send an ETWS cancel broadcast message to app. */
117        Button etwsCancelTypeButton = (Button) findViewById(R.id.button_etws_cancel_type);
118        etwsCancelTypeButton.setOnClickListener(new OnClickListener() {
119            public void onClick(View v) {
120                if (mDelayBeforeSending && v != null) {
121                    Message msg = mDelayHandler.obtainMessage(0, this);
122                    mDelayHandler.sendMessageDelayed(msg, DELAY_BEFORE_SENDING_MSEC);
123                } else {
124                    SendTestMessages.testSendEtwsMessageCancel(SendTestBroadcastActivity.this,
125                            getMessageId());
126                }
127            }
128        });
129
130        /* Send an ETWS test broadcast message to app. */
131        Button etwsTestTypeButton = (Button) findViewById(R.id.button_etws_test_type);
132        etwsTestTypeButton.setOnClickListener(new OnClickListener() {
133            public void onClick(View v) {
134                if (mDelayBeforeSending && v != null) {
135                    Message msg = mDelayHandler.obtainMessage(0, this);
136                    mDelayHandler.sendMessageDelayed(msg, DELAY_BEFORE_SENDING_MSEC);
137                } else {
138                    SendTestMessages.testSendEtwsMessageTest(SendTestBroadcastActivity.this,
139                            getMessageId());
140                }
141            }
142        });
143
144        /* Send a CMAS presidential alert to app. */
145        Button cmasPresAlertButton = (Button) findViewById(R.id.button_cmas_pres_alert);
146        cmasPresAlertButton.setOnClickListener(new OnClickListener() {
147            public void onClick(View v) {
148                if (mDelayBeforeSending && v != null) {
149                    Message msg = mDelayHandler.obtainMessage(0, this);
150                    mDelayHandler.sendMessageDelayed(msg, DELAY_BEFORE_SENDING_MSEC);
151                } else {
152                    SendCdmaCmasMessages.testSendCmasPresAlert(SendTestBroadcastActivity.this,
153                            getMessageId());
154                }
155            }
156        });
157
158        /* Send a CMAS extreme alert to app. */
159        Button cmasExtremeAlertButton = (Button) findViewById(R.id.button_cmas_extreme_alert);
160        cmasExtremeAlertButton.setOnClickListener(new OnClickListener() {
161            public void onClick(View v) {
162                if (mDelayBeforeSending && v != null) {
163                    Message msg = mDelayHandler.obtainMessage(0, this);
164                    mDelayHandler.sendMessageDelayed(msg, DELAY_BEFORE_SENDING_MSEC);
165                } else {
166                    SendCdmaCmasMessages.testSendCmasExtremeAlert(SendTestBroadcastActivity.this,
167                            getMessageId());
168                }
169            }
170        });
171
172        /* Send a CMAS severe alert to app. */
173        Button cmasSevereAlertButton = (Button) findViewById(R.id.button_cmas_severe_alert);
174        cmasSevereAlertButton.setOnClickListener(new OnClickListener() {
175            public void onClick(View v) {
176                if (mDelayBeforeSending && v != null) {
177                    Message msg = mDelayHandler.obtainMessage(0, this);
178                    mDelayHandler.sendMessageDelayed(msg, DELAY_BEFORE_SENDING_MSEC);
179                } else {
180                    SendCdmaCmasMessages.testSendCmasSevereAlert(SendTestBroadcastActivity.this,
181                            getMessageId());
182                }
183            }
184        });
185
186        /* Send a CMAS AMBER alert to app. */
187        Button cmasAmberAlertButton = (Button) findViewById(R.id.button_cmas_amber_alert);
188        cmasAmberAlertButton.setOnClickListener(new OnClickListener() {
189            public void onClick(View v) {
190                if (mDelayBeforeSending && v != null) {
191                    Message msg = mDelayHandler.obtainMessage(0, this);
192                    mDelayHandler.sendMessageDelayed(msg, DELAY_BEFORE_SENDING_MSEC);
193                } else {
194                    SendCdmaCmasMessages.testSendCmasAmberAlert(SendTestBroadcastActivity.this,
195                            getMessageId());
196                }
197            }
198        });
199
200        /* Send a CMAS monthly test alert to app. */
201        Button cmasMonthlyTestButton = (Button) findViewById(R.id.button_cmas_monthly_test);
202        cmasMonthlyTestButton.setOnClickListener(new OnClickListener() {
203            public void onClick(View v) {
204                if (mDelayBeforeSending && v != null) {
205                    Message msg = mDelayHandler.obtainMessage(0, this);
206                    mDelayHandler.sendMessageDelayed(msg, DELAY_BEFORE_SENDING_MSEC);
207                } else {
208                    SendCdmaCmasMessages.testSendCmasMonthlyTest(SendTestBroadcastActivity.this,
209                            getMessageId());
210                }
211            }
212        });
213
214        /* Send a GSM 7-bit broadcast message to app. */
215        Button gsm7bitTypeButton = (Button) findViewById(R.id.button_gsm_7bit_type);
216        gsm7bitTypeButton.setOnClickListener(new OnClickListener() {
217            public void onClick(View v) {
218                if (mDelayBeforeSending && v != null) {
219                    Message msg = mDelayHandler.obtainMessage(0, this);
220                    mDelayHandler.sendMessageDelayed(msg, DELAY_BEFORE_SENDING_MSEC);
221                } else {
222                    SendTestMessages.testSendMessage7bit(SendTestBroadcastActivity.this,
223                            getMessageId(), getCategory());
224                }
225            }
226        });
227
228        /* Send a UMTS 7-bit broadcast message to app. */
229        Button gsm7bitUmtsTypeButton = (Button) findViewById(R.id.button_gsm_7bit_umts_type);
230        gsm7bitUmtsTypeButton.setOnClickListener(new OnClickListener() {
231            public void onClick(View v) {
232                if (mDelayBeforeSending && v != null) {
233                    Message msg = mDelayHandler.obtainMessage(0, this);
234                    mDelayHandler.sendMessageDelayed(msg, DELAY_BEFORE_SENDING_MSEC);
235                } else {
236                    SendTestMessages.testSendMessage7bitUmts(SendTestBroadcastActivity.this,
237                            getMessageId(), getCategory());
238                }
239            }
240        });
241
242        /* Send a GSM 7-bit no padding broadcast message to app. */
243        Button gsm7bitNoPaddingButton = (Button) findViewById(R.id.button_gsm_7bit_nopadding_type);
244        gsm7bitNoPaddingButton.setOnClickListener(new OnClickListener() {
245            public void onClick(View v) {
246                if (mDelayBeforeSending && v != null) {
247                    Message msg = mDelayHandler.obtainMessage(0, this);
248                    mDelayHandler.sendMessageDelayed(msg, DELAY_BEFORE_SENDING_MSEC);
249                } else {
250                    SendTestMessages.testSendMessage7bitNoPadding(SendTestBroadcastActivity.this,
251                            getMessageId(), getCategory());
252                }
253            }
254        });
255
256        /* Send a UMTS 7-bit no padding broadcast message to app. */
257        Button gsm7bitNoPaddingUmtsTypeButton =
258                (Button) findViewById(R.id.button_gsm_7bit_nopadding_umts_type);
259        gsm7bitNoPaddingUmtsTypeButton.setOnClickListener(new OnClickListener() {
260            public void onClick(View v) {
261                if (mDelayBeforeSending && v != null) {
262                    Message msg = mDelayHandler.obtainMessage(0, this);
263                    mDelayHandler.sendMessageDelayed(msg, DELAY_BEFORE_SENDING_MSEC);
264                } else {
265                    SendTestMessages.testSendMessage7bitNoPaddingUmts(
266                            SendTestBroadcastActivity.this, getMessageId(), getCategory());
267                }
268            }
269        });
270
271        /* Send a UMTS 7-bit multi-page broadcast message to app. */
272        Button gsm7bitMultipageButton =
273                (Button) findViewById(R.id.button_gsm_7bit_multipage_type);
274        gsm7bitMultipageButton.setOnClickListener(new OnClickListener() {
275            public void onClick(View v) {
276                if (mDelayBeforeSending && v != null) {
277                    Message msg = mDelayHandler.obtainMessage(0, this);
278                    mDelayHandler.sendMessageDelayed(msg, DELAY_BEFORE_SENDING_MSEC);
279                } else {
280                    SendTestMessages.testSendMessage7bitMultipageGsm(SendTestBroadcastActivity.this,
281                            getMessageId(), getCategory());
282                }
283            }
284        });
285
286        /* Send a UMTS 7-bit multi-page broadcast message to app. */
287        Button gsm7bitMultipageUmtsButton =
288                (Button) findViewById(R.id.button_gsm_7bit_multipage_umts_type);
289        gsm7bitMultipageUmtsButton.setOnClickListener(new OnClickListener() {
290            public void onClick(View v) {
291                if (mDelayBeforeSending && v != null) {
292                    Message msg = mDelayHandler.obtainMessage(0, this);
293                    mDelayHandler.sendMessageDelayed(msg, DELAY_BEFORE_SENDING_MSEC);
294                } else {
295                    SendTestMessages.testSendMessage7bitMultipageUmts(
296                            SendTestBroadcastActivity.this, getMessageId(), getCategory());
297                }
298            }
299        });
300
301        /* Send a GSM 7-bit broadcast message with language to app. */
302        Button gsm7bitWithLanguageButton =
303                (Button) findViewById(R.id.button_gsm_7bit_with_language_type);
304        gsm7bitWithLanguageButton.setOnClickListener(new OnClickListener() {
305            public void onClick(View v) {
306                if (mDelayBeforeSending && v != null) {
307                    Message msg = mDelayHandler.obtainMessage(0, this);
308                    mDelayHandler.sendMessageDelayed(msg, DELAY_BEFORE_SENDING_MSEC);
309                } else {
310                    SendTestMessages.testSendMessage7bitWithLanguage(SendTestBroadcastActivity.this,
311                            getMessageId(), getCategory());
312                }
313            }
314        });
315
316        /* Send a GSM 7-bit broadcast message with language to app. */
317        Button gsm7bitWithLanguageInBodyButton =
318                (Button) findViewById(R.id.button_gsm_7bit_with_language_body_gsm_type);
319        gsm7bitWithLanguageInBodyButton.setOnClickListener(new OnClickListener() {
320            public void onClick(View v) {
321                if (mDelayBeforeSending && v != null) {
322                    Message msg = mDelayHandler.obtainMessage(0, this);
323                    mDelayHandler.sendMessageDelayed(msg, DELAY_BEFORE_SENDING_MSEC);
324                } else {
325                    SendTestMessages.testSendMessage7bitWithLanguageInBody(
326                            SendTestBroadcastActivity.this, getMessageId(), getCategory());
327                }
328            }
329        });
330
331        /* Send a UMTS 7-bit broadcast message with language to app. */
332        Button gsm7bitWithLanguageUmtsButton =
333                (Button) findViewById(R.id.button_gsm_7bit_with_language_body_umts_type);
334        gsm7bitWithLanguageUmtsButton.setOnClickListener(new OnClickListener() {
335            public void onClick(View v) {
336                if (mDelayBeforeSending && v != null) {
337                    Message msg = mDelayHandler.obtainMessage(0, this);
338                    mDelayHandler.sendMessageDelayed(msg, DELAY_BEFORE_SENDING_MSEC);
339                } else {
340                    SendTestMessages.testSendMessage7bitWithLanguageInBodyUmts(
341                            SendTestBroadcastActivity.this, getMessageId(), getCategory());
342                }
343            }
344        });
345
346        /* Send a GSM UCS-2 broadcast message to app. */
347        Button gsmUcs2TypeButton = (Button) findViewById(R.id.button_gsm_ucs2_type);
348        gsmUcs2TypeButton.setOnClickListener(new OnClickListener() {
349            public void onClick(View v) {
350                if (mDelayBeforeSending && v != null) {
351                    Message msg = mDelayHandler.obtainMessage(0, this);
352                    mDelayHandler.sendMessageDelayed(msg, DELAY_BEFORE_SENDING_MSEC);
353                } else {
354                    SendTestMessages.testSendMessageUcs2(SendTestBroadcastActivity.this,
355                            getMessageId(), getCategory());
356                }
357            }
358        });
359
360        /* Send a UMTS UCS-2 broadcast message to app. */
361        Button gsmUcs2UmtsTypeButton = (Button) findViewById(R.id.button_gsm_ucs2_umts_type);
362        gsmUcs2UmtsTypeButton.setOnClickListener(new OnClickListener() {
363            public void onClick(View v) {
364                if (mDelayBeforeSending && v != null) {
365                    Message msg = mDelayHandler.obtainMessage(0, this);
366                    mDelayHandler.sendMessageDelayed(msg, DELAY_BEFORE_SENDING_MSEC);
367                } else {
368                    SendTestMessages.testSendMessageUcs2Umts(SendTestBroadcastActivity.this,
369                            getMessageId(), getCategory());
370                }
371            }
372        });
373
374        /* Send a UMTS UCS-2 multipage broadcast message to app. */
375        Button gsmUcs2MultipageUmtsTypeButton =
376                (Button) findViewById(R.id.button_gsm_ucs2_multipage_umts_type);
377        gsmUcs2MultipageUmtsTypeButton.setOnClickListener(new OnClickListener() {
378            public void onClick(View v) {
379                if (mDelayBeforeSending && v != null) {
380                    Message msg = mDelayHandler.obtainMessage(0, this);
381                    mDelayHandler.sendMessageDelayed(msg, DELAY_BEFORE_SENDING_MSEC);
382                } else {
383                    SendTestMessages.testSendMessageUcs2MultipageUmts(
384                            SendTestBroadcastActivity.this, getMessageId(), getCategory());
385                }
386            }
387        });
388
389        /* Send a GSM UCS-2 broadcast message with language to app. */
390        Button gsmUcs2WithLanguageTypeButton =
391                (Button) findViewById(R.id.button_gsm_ucs2_with_language_type);
392        gsmUcs2WithLanguageTypeButton.setOnClickListener(new OnClickListener() {
393            public void onClick(View v) {
394                if (mDelayBeforeSending && v != null) {
395                    Message msg = mDelayHandler.obtainMessage(0, this);
396                    mDelayHandler.sendMessageDelayed(msg, DELAY_BEFORE_SENDING_MSEC);
397                } else {
398                    SendTestMessages.testSendMessageUcs2WithLanguageInBody(
399                            SendTestBroadcastActivity.this, getMessageId(), getCategory());
400                }
401            }
402        });
403
404        /* Send a UMTS UCS-2 broadcast message with language to app. */
405        Button gsmUcs2WithLanguageUmtsTypeButton =
406                (Button) findViewById(R.id.button_gsm_ucs2_with_language_umts_type);
407        gsmUcs2WithLanguageUmtsTypeButton.setOnClickListener(new OnClickListener() {
408            public void onClick(View v) {
409                if (mDelayBeforeSending && v != null) {
410                    Message msg = mDelayHandler.obtainMessage(0, this);
411                    mDelayHandler.sendMessageDelayed(msg, DELAY_BEFORE_SENDING_MSEC);
412                } else {
413                    SendTestMessages.testSendMessageUcs2WithLanguageUmts(
414                            SendTestBroadcastActivity.this, getMessageId(), getCategory());
415                }
416            }
417        });
418
419        /* Update boolean to delay before sending when box is checked. */
420        final CheckBox delayCheckbox = (CheckBox) findViewById(R.id.button_delay_broadcast);
421        delayCheckbox.setOnClickListener(new OnClickListener() {
422            public void onClick(View v) {
423                mDelayBeforeSending = delayCheckbox.isChecked();
424            }
425        });
426    }
427}
428