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
|
/*
* Copyright (C) 2013 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 android.print;
import android.content.Context;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.CancellationSignal;
import android.os.CancellationSignal.OnCancelListener;
import android.os.ParcelFileDescriptor;
import android.util.Log;
import com.android.internal.R;
import libcore.io.IoUtils;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/**
* Adapter for printing PDF files. This class could be useful if you
* want to print a file and intercept when the system is ready
* spooling the data, so you can delete the file if it is a
* temporary one. To achieve this one must override {@link #onFinish()}
* and delete the file yourself.
*
* @hide
*/
public class PrintFileDocumentAdapter extends PrintDocumentAdapter {
private static final String LOG_TAG = "PrintedFileDocumentAdapter";
private final Context mContext;
private final File mFile;
private final PrintDocumentInfo mDocumentInfo;
private WriteFileAsyncTask mWriteFileAsyncTask;
/**
* Constructor.
*
* @param context Context for accessing resources.
* @param file The PDF file to print.
* @param documentInfo The information about the printed file.
*/
public PrintFileDocumentAdapter(Context context, File file,
PrintDocumentInfo documentInfo) {
if (file == null) {
throw new IllegalArgumentException("File cannot be null!");
}
if (documentInfo == null) {
throw new IllegalArgumentException("documentInfo cannot be null!");
}
mContext = context;
mFile = file;
mDocumentInfo = documentInfo;
}
@Override
public void onLayout(PrintAttributes oldAttributes, PrintAttributes newAttributes,
CancellationSignal cancellationSignal, LayoutResultCallback callback,
Bundle metadata) {
callback.onLayoutFinished(mDocumentInfo, false);
}
@Override
public void onWrite(PageRange[] pages, ParcelFileDescriptor destination,
CancellationSignal cancellationSignal, WriteResultCallback callback) {
mWriteFileAsyncTask = new WriteFileAsyncTask(destination, cancellationSignal, callback);
mWriteFileAsyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,
(Void[]) null);
}
private final class WriteFileAsyncTask extends AsyncTask<Void, Void, Void> {
private final ParcelFileDescriptor mDestination;
private final WriteResultCallback mResultCallback;
private final CancellationSignal mCancellationSignal;
public WriteFileAsyncTask(ParcelFileDescriptor destination,
CancellationSignal cancellationSignal, WriteResultCallback callback) {
mDestination = destination;
mResultCallback = callback;
mCancellationSignal = cancellationSignal;
mCancellationSignal.setOnCancelListener(new OnCancelListener() {
@Override
public void onCancel() {
cancel(true);
}
});
}
@Override
protected Void doInBackground(Void... params) {
InputStream in = null;
OutputStream out = new FileOutputStream(mDestination.getFileDescriptor());
final byte[] buffer = new byte[8192];
try {
in = new FileInputStream(mFile);
while (true) {
if (isCancelled()) {
break;
}
final int readByteCount = in.read(buffer);
if (readByteCount < 0) {
break;
}
out.write(buffer, 0, readByteCount);
}
} catch (IOException ioe) {
Log.e(LOG_TAG, "Error writing data!", ioe);
mResultCallback.onWriteFailed(mContext.getString(
R.string.write_fail_reason_cannot_write));
} finally {
IoUtils.closeQuietly(in);
IoUtils.closeQuietly(out);
}
return null;
}
@Override
protected void onPostExecute(Void result) {
mResultCallback.onWriteFinished(new PageRange[] {PageRange.ALL_PAGES});
}
@Override
protected void onCancelled(Void result) {
mResultCallback.onWriteFailed(mContext.getString(
R.string.write_fail_reason_cancelled));
}
}
}
|
