1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
|
/*
* Copyright 2014, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.managedprovisioning;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.admin.DevicePolicyManager;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.provider.Settings.Global;
import android.support.v4.content.LocalBroadcastManager;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.TextView;
/**
* This activity starts device owner provisioning:
* It downloads a mobile device management application(mdm) from a given url and installs it,
* or a given mdm is already present on the device. The mdm is set as the owner of the device so
* that it has full control over the device:
* TODO: put link here with documentation on how a device owner has control over the device
* The mdm can then execute further setup steps.
*
* <p>
* An example use case might be when a company wants to set up a device for a single use case
* (such as giving instructions).
* </p>
*
* <p>
* Provisioning is triggered by a programmer device that sends required provisioning parameters via
* nfc. For an example of a programmer app see:
* com.example.android.apis.app.DeviceProvisioningProgrammerSample.
* </p>
*
* <p>
* In the unlikely case that this activity is killed the whole provisioning process so far is
* repeated. We made sure that all tasks can be done twice without causing any problems.
* </p>
*/
public class DeviceOwnerProvisioningActivity extends Activity {
private static final int ENCRYPT_DEVICE_REQUEST_CODE = 1;
private BroadcastReceiver mServiceMessageReceiver;
private TextView mProgressTextView;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
ProvisionLogger.logd("Device owner provisioning activity ONCREATE");
// Check whether we can provision.
if (Global.getInt(getContentResolver(), Global.DEVICE_PROVISIONED, /* default */ 0) != 0) {
ProvisionLogger.loge("Device already provisioned.");
error(R.string.device_owner_error_already_provisioned);
return;
}
DevicePolicyManager dpm = (DevicePolicyManager)
getSystemService(Context.DEVICE_POLICY_SERVICE);
if (dpm.getDeviceOwner() != null) {
ProvisionLogger.loge("Device owner already present.");
error(R.string.device_owner_error_already_owned);
return;
}
final LayoutInflater inflater = getLayoutInflater();
final View contentView = inflater.inflate(R.layout.progress, null);
setContentView(contentView);
mProgressTextView = (TextView) findViewById(R.id.prog_text);
// Setup broadcast receiver for feedback from service.
mServiceMessageReceiver = new ServiceMessageReceiver();
IntentFilter filter = new IntentFilter();
filter.addAction(DeviceOwnerProvisioningService.ACTION_PROVISIONING_SUCCESS);
filter.addAction(DeviceOwnerProvisioningService.ACTION_PROVISIONING_ERROR);
filter.addAction(DeviceOwnerProvisioningService.ACTION_PROGRESS_UPDATE);
filter.addAction(DeviceOwnerProvisioningService.ACTION_REQUEST_ENCRYPTION);
LocalBroadcastManager.getInstance(this).registerReceiver(mServiceMessageReceiver, filter);
// Start service.
Intent intent = new Intent(this, DeviceOwnerProvisioningService.class);
intent.putExtras(getIntent());
startService(intent);
}
class ServiceMessageReceiver extends BroadcastReceiver
{
@Override
public void onReceive(Context context, Intent intent)
{
String action = intent.getAction();
if (action.equals(DeviceOwnerProvisioningService.ACTION_PROVISIONING_SUCCESS)) {
ProvisionLogger.logd("Successfully provisioned");
finish();
return;
} else if (action.equals(DeviceOwnerProvisioningService.ACTION_PROVISIONING_ERROR)) {
int errorCode = intent.getIntExtra(
DeviceOwnerProvisioningService.EXTRA_USER_VISIBLE_ERROR_ID_KEY, -1);
ProvisionLogger.logd("Error reported with code "
+ getResources().getString(errorCode));
if (errorCode < 0) {
error(R.string.device_owner_error_general);
return;
} else {
error(errorCode);
}
} else if (action.equals(DeviceOwnerProvisioningService.ACTION_PROGRESS_UPDATE)) {
int progressMessage = intent.getIntExtra(
DeviceOwnerProvisioningService.EXTRA_PROGRESS_MESSAGE_ID_KEY, -1);
ProvisionLogger.logd("Progress update reported with code "
+ getResources().getString(progressMessage));
if (progressMessage >= 0) {
progressUpdate(progressMessage);
}
} else if (action.equals(DeviceOwnerProvisioningService.ACTION_REQUEST_ENCRYPTION)) {
ProvisionLogger.logd("Received request to encrypt device.");
Intent encryptIntent = new Intent(DeviceOwnerProvisioningActivity.this,
EncryptDeviceActivity.class);
encryptIntent.putExtras(intent);
startActivityForResult(encryptIntent, ENCRYPT_DEVICE_REQUEST_CODE);
}
}
}
@Override
public void onBackPressed() {
// TODO: Handle this graciously by stopping the provisioning flow and cleaning up.
}
@Override
public void onDestroy() {
ProvisionLogger.logd("Device owner provisioning activity ONDESTROY");
LocalBroadcastManager.getInstance(this).unregisterReceiver(mServiceMessageReceiver);
super.onDestroy();
}
private void progressUpdate(int progressMessage) {
mProgressTextView.setText(progressMessage);
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (requestCode == ENCRYPT_DEVICE_REQUEST_CODE) {
if (resultCode == RESULT_CANCELED) {
ProvisionLogger.loge("User canceled device encryption.");
finish();
}
}
}
private void error(int dialogMessage) {
AlertDialog dlg = new AlertDialog.Builder(this)
.setTitle(R.string.device_owner_error_title)
.setMessage(dialogMessage)
.setCancelable(false)
.setPositiveButton("OK", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog,int id) {
// Close activity
finish();
}
})
.create();
dlg.show();
}
@Override
protected void onRestart() {
ProvisionLogger.logd("Device owner provisioning activity ONRESTART");
super.onRestart();
}
@Override
protected void onResume() {
ProvisionLogger.logd("Device owner provisioning activity ONRESUME");
super.onResume();
}
@Override
protected void onPause() {
ProvisionLogger.logd("Device owner provisioning activity ONPAUSE");
super.onPause();
}
@Override
protected void onStop() {
ProvisionLogger.logd("Device owner provisioning activity ONSTOP");
super.onStop();
}
}
|
