iterator = sFileTypeMap.keySet().iterator();
128 |
129 | while (iterator.hasNext()) {
130 | if (builder.length() > 0)
131 | builder.append(',');
132 | builder.append(iterator.next());
133 | }
134 | sFileExtensions = builder.toString();
135 | }
136 |
137 | static void addFileType(String extension, int fileType, String mimeType) {
138 | sFileTypeMap.put(extension, new MediaFileType(fileType, mimeType));
139 | sMimeTypeMap.put(mimeType, Integer.valueOf(fileType));
140 | }
141 |
142 | public static boolean isAudioFileType(int fileType) {
143 | return (fileType >= FIRST_AUDIO_FILE_TYPE && fileType <= LAST_AUDIO_FILE_TYPE);
144 | }
145 |
146 | public static boolean isVideoFileType(int fileType) {
147 | return (fileType >= FIRST_VIDEO_FILE_TYPE && fileType <= LAST_VIDEO_FILE_TYPE);
148 | }
149 |
150 | public static MediaFileType getFileType(String path) {
151 | int lastDot = path.lastIndexOf(".");
152 | if (lastDot < 0)
153 | return null;
154 | return sFileTypeMap.get(path.substring(lastDot + 1).toUpperCase());
155 | }
156 |
157 | public static int getFileTypeForMimeType(String mimeType) {
158 | Integer value = sMimeTypeMap.get(mimeType);
159 | return (value == null ? 0 : value.intValue());
160 | }
161 |
162 | protected static class MediaFileType {
163 | int fileType;
164 | String mimeType;
165 |
166 | MediaFileType(int fileType, String mimeType) {
167 | this.fileType = fileType;
168 | this.mimeType = mimeType;
169 | }
170 | }
171 |
172 | }
--------------------------------------------------------------------------------
/vitamio/src/io/vov/vitamio/MediaMetadataRetriever.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2008 The Android Open Source Project
3 | * Copyright (C) 2013 YIXIA.COM
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 io.vov.vitamio;
19 |
20 | import android.content.ContentResolver;
21 | import android.content.Context;
22 | import android.content.res.AssetFileDescriptor;
23 | import android.graphics.Bitmap;
24 | import android.net.Uri;
25 | import android.util.Log;
26 |
27 | import java.io.FileDescriptor;
28 | import java.io.IOException;
29 |
30 | import io.vov.vitamio.utils.FileUtils;
31 |
32 | /**
33 | * MediaMetadataRetriever is used to get meta data from any media file
34 | *
35 | *
36 | * MediaMetadataRetriever mmr = new MediaMetadataRetriever(this);
37 | * mmr.setDataSource(this, mediaUri);
38 | * String title = mmr.extractMetadata(METADATA_KEY_TITLE);
39 | * Bitmap frame = mmr.getFrameAtTime(-1);
40 | *
41 | */
42 | public class MediaMetadataRetriever {
43 | /**
44 | * The metadata key to retrieve the information about the album title
45 | * of the data source.
46 | */
47 | public static final String METADATA_KEY_ALBUM = "album";
48 | /**
49 | * The metadata key to retrieve the information about the artist of
50 | * the data source.
51 | */
52 | public static final String METADATA_KEY_ARTIST = "artist";
53 | /**
54 | * The metadata key to retrieve the information about the author of
55 | * the data source.
56 | */
57 | public static final String METADATA_KEY_AUTHOR = "author";
58 | /**
59 | * The metadata key to retrieve the information about the composer of
60 | * the data source.
61 | */
62 | public static final String METADATA_KEY_COMPOSER = "composer";
63 | /**
64 | * The metadata key to retrieve the content type or genre of the data
65 | * source.
66 | */
67 | public static final String METADATA_KEY_GENRE = "genre";
68 | /**
69 | * The metadata key to retrieve the data source title.
70 | */
71 | public static final String METADATA_KEY_TITLE = "title";
72 | /**
73 | * The metadata key to retrieve the playback duration of the data source.
74 | */
75 | public static final String METADATA_KEY_DURATION = "duration";
76 | /**
77 | * If the media contains video, this key retrieves its width.
78 | */
79 | public static final String METADATA_KEY_VIDEO_WIDTH = "width";
80 | /**
81 | * If the media contains video, this key retrieves its height.
82 | */
83 | public static final String METADATA_KEY_VIDEO_HEIGHT = "height";
84 |
85 | static {
86 | String LIB_ROOT = Vitamio.getLibraryPath();
87 | Log.i("LIB ROOT: %s", LIB_ROOT);
88 | System.load(LIB_ROOT + "libstlport_shared.so");
89 | System.load(LIB_ROOT + "libvscanner.so");
90 | loadFFmpeg_native(LIB_ROOT + "libffmpeg.so");
91 | }
92 |
93 | private Context mContext;
94 | private AssetFileDescriptor mFD = null;
95 |
96 | public MediaMetadataRetriever(Context ctx) {
97 | mContext = ctx;
98 | native_init();
99 | }
100 |
101 | private static native boolean loadFFmpeg_native(String ffmpegPath);
102 |
103 | public void setDataSource(Context context, Uri uri) throws IOException, IllegalArgumentException, SecurityException, IllegalStateException {
104 | if (context == null || uri == null)
105 | throw new IllegalArgumentException();
106 | String scheme = uri.getScheme();
107 | if (scheme == null || scheme.equals("file")) {
108 | setDataSource(FileUtils.getPath(uri.toString()));
109 | return;
110 | }
111 |
112 | try {
113 | ContentResolver resolver = context.getContentResolver();
114 | mFD = resolver.openAssetFileDescriptor(uri, "r");
115 | if (mFD == null)
116 | return;
117 | setDataSource(mFD.getParcelFileDescriptor().getFileDescriptor());
118 | return;
119 | } catch (Exception e) {
120 | closeFD();
121 | }
122 | Log.e("Couldn't open file on client side, trying server side %s", uri.toString());
123 | setDataSource(uri.toString());
124 | return;
125 | }
126 |
127 | public native void setDataSource(String path) throws IOException, IllegalArgumentException, IllegalStateException;
128 |
129 | /*
130 | * Do not change these metadata key values without updating their
131 | * counterparts in c file
132 | */
133 |
134 | public native void setDataSource(FileDescriptor fd) throws IOException, IllegalArgumentException, IllegalStateException;
135 |
136 | /**
137 | * Call this method after setDataSource(). This method retrieves the
138 | * meta data value associated with the keyCode.
139 | *
140 | * The keyCode currently supported is listed below as METADATA_XXX
141 | * constants. With any other value, it returns a null pointer.
142 | *
143 | * @param keyCode One of the constants listed below at the end of the class.
144 | * @return The meta data value associate with the given keyCode on success;
145 | * null on failure.
146 | */
147 | public native String extractMetadata(String keyCode) throws IllegalStateException;
148 |
149 | public native Bitmap getFrameAtTime(long timeUs) throws IllegalStateException;
150 |
151 | private native void _release();
152 |
153 | public void release() {
154 | _release();
155 | closeFD();
156 | }
157 |
158 | private native final void native_init();
159 |
160 | private native final void native_finalize();
161 |
162 | @Override
163 | protected void finalize() throws Throwable {
164 | try {
165 | native_finalize();
166 | } finally {
167 | super.finalize();
168 | }
169 | }
170 |
171 | private void closeFD() {
172 | if (mFD != null) {
173 | try {
174 | mFD.close();
175 | } catch (IOException e) {
176 | }
177 | mFD = null;
178 | }
179 | }
180 |
181 | }
--------------------------------------------------------------------------------
/vitamio/src/io/vov/vitamio/MediaScannerClient.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2006 The Android Open Source Project
3 | * Copyright (C) 2013 YIXIA.COM
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 io.vov.vitamio;
19 |
20 | /**
21 | * DON'T TOUCH THIS FILE IF YOU DON'T KNOW THE MediaScanner PROCEDURE!!!
22 | */
23 | public interface MediaScannerClient {
24 | void scanFile(String path, long lastModified, long fileSize);
25 |
26 | void addNoMediaFolder(String path);
27 |
28 | void handleStringTag(String name, byte[] value, String valueEncoding);
29 |
30 | void setMimeType(String mimeType);
31 | }
--------------------------------------------------------------------------------
/vitamio/src/io/vov/vitamio/Metadata.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2006 The Android Open Source Project
3 | * Copyright (C) 2013 YIXIA.COM
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 io.vov.vitamio;
19 |
20 | import android.util.SparseArray;
21 |
22 | import java.io.UnsupportedEncodingException;
23 | import java.util.Locale;
24 | import java.util.Map;
25 |
26 | /**
27 | * See {@link io.vov.vitamio.MediaPlayer#getMetadata()}
28 | */
29 | public class Metadata {
30 | public static final int ANY = 0;
31 | public static final int TITLE = 1; // String
32 | public static final int COMMENT = 2; // String
33 | public static final int COPYRIGHT = 3; // String
34 | public static final int ALBUM = 4; // String
35 | public static final int ARTIST = 5; // String
36 | public static final int AUTHOR = 6; // String
37 | public static final int COMPOSER = 7; // String
38 | public static final int GENRE = 8; // String
39 | public static final int DATE = 9; // Date
40 | public static final int DURATION = 10; // Integer(milliseconds)
41 | public static final int CD_TRACK_NUM = 11; // Integer (1-based)
42 | public static final int CD_TRACK_MAX = 12; // Integer
43 | public static final int RATING = 13; // String
44 | public static final int ALBUM_ART = 14; // byte[]
45 | public static final int VIDEO_FRAME = 15; // Bitmap
46 | public static final int LENGTH = 16; // Integer (bytes)
47 | public static final int BIT_RATE = 17; // Integer
48 | public static final int AUDIO_BIT_RATE = 18; // Integer
49 | public static final int VIDEO_BIT_RATE = 19; // Integer
50 | public static final int AUDIO_SAMPLE_RATE = 20; // Integer
51 | public static final int VIDEO_FRAME_RATE = 21; // Float
52 | // See RFC2046 and RFC4281.
53 | public static final int MIME_TYPE = 22; // String
54 | public static final int AUDIO_CODEC = 23; // String
55 | public static final int VIDEO_CODEC = 24; // String
56 | public static final int VIDEO_HEIGHT = 25; // Integer
57 | public static final int VIDEO_WIDTH = 26; // Integer
58 | public static final int NUM_TRACKS = 27; // Integer
59 | public static final int DRM_CRIPPLED = 28; // Boolean
60 | public static final int PAUSE_AVAILABLE = 29; // Boolean
61 | public static final int SEEK_BACKWARD_AVAILABLE = 30; // Boolean
62 | public static final int SEEK_FORWARD_AVAILABLE = 31; // Boolean
63 | public static final int SEEK_AVAILABLE = 32; // Boolean
64 | private static final int LAST_SYSTEM = 32;
65 | private static final int FIRST_CUSTOM = 8192;
66 | private SparseArray mMeta = new SparseArray();
67 | private String mEncoding = "UTF-8";
68 |
69 | public boolean parse(Map meta, String encoding) {
70 | String key = null;
71 | byte[] value = null;
72 | mEncoding = encoding;
73 | for (byte[] keyBytes : meta.keySet()) {
74 | try {
75 | key = new String(keyBytes, mEncoding).trim().toLowerCase(Locale.US);
76 | } catch (UnsupportedEncodingException e) {
77 | key = new String(keyBytes).trim().toLowerCase(Locale.US);
78 | }
79 | value = meta.get(keyBytes);
80 | if (key.equals("title")) {
81 | mMeta.put(TITLE, value);
82 | } else if (key.equals("comment")) {
83 | mMeta.put(COMMENT, value);
84 | } else if (key.equals("copyright")) {
85 | mMeta.put(COPYRIGHT, value);
86 | } else if (key.equals("album")) {
87 | mMeta.put(ALBUM, value);
88 | } else if (key.equals("artist")) {
89 | mMeta.put(ARTIST, value);
90 | } else if (key.equals("author")) {
91 | mMeta.put(AUTHOR, value);
92 | } else if (key.equals("composer")) {
93 | mMeta.put(COMPOSER, value);
94 | } else if (key.equals("genre")) {
95 | mMeta.put(GENRE, value);
96 | } else if (key.equals("creation_time") || key.equals("date")) {
97 | mMeta.put(DATE, value);
98 | } else if (key.equals("duration")) {
99 | mMeta.put(DURATION, value);
100 | } else if (key.equals("length")) {
101 | mMeta.put(LENGTH, value);
102 | } else if (key.equals("bit_rate")) {
103 | mMeta.put(BIT_RATE, value);
104 | } else if (key.equals("audio_bit_rate")) {
105 | mMeta.put(AUDIO_BIT_RATE, value);
106 | } else if (key.equals("video_bit_rate")) {
107 | mMeta.put(VIDEO_BIT_RATE, value);
108 | } else if (key.equals("audio_sample_rate")) {
109 | mMeta.put(AUDIO_SAMPLE_RATE, value);
110 | } else if (key.equals("video_frame_rate")) {
111 | mMeta.put(VIDEO_FRAME_RATE, value);
112 | } else if (key.equals("format")) {
113 | mMeta.put(MIME_TYPE, value);
114 | } else if (key.equals("audio_codec")) {
115 | mMeta.put(AUDIO_CODEC, value);
116 | } else if (key.equals("video_codec")) {
117 | mMeta.put(VIDEO_CODEC, value);
118 | } else if (key.equals("video_height")) {
119 | mMeta.put(VIDEO_HEIGHT, value);
120 | } else if (key.equals("video_width")) {
121 | mMeta.put(VIDEO_WIDTH, value);
122 | } else if (key.equals("num_tracks")) {
123 | mMeta.put(NUM_TRACKS, value);
124 | } else if (key.equals("cap_pause")) {
125 | mMeta.put(PAUSE_AVAILABLE, value);
126 | } else if (key.equals("cap_seek")) {
127 | mMeta.put(SEEK_AVAILABLE, value);
128 | }
129 | }
130 |
131 | if (BuildConfig.DEBUG) {
132 | android.util.Log.i("Vitamio[Metadata]", "title:\t\t" + getString(TITLE));
133 | android.util.Log.i("Vitamio[Metadata]", "comment:\t\t" + getString(COMMENT));
134 | android.util.Log.i("Vitamio[Metadata]", "copyright:\t\t" + getString(COPYRIGHT));
135 | android.util.Log.i("Vitamio[Metadata]", "album:\t\t" + getString(ALBUM));
136 | android.util.Log.i("Vitamio[Metadata]", "artist:\t\t" + getString(ARTIST));
137 | android.util.Log.i("Vitamio[Metadata]", "composer:\t\t" + getString(COMPOSER));
138 | android.util.Log.i("Vitamio[Metadata]", "genre:\t\t" + getString(GENRE));
139 | android.util.Log.i("Vitamio[Metadata]", "date:\t\t" + getString(DATE));
140 | android.util.Log.i("Vitamio[Metadata]", "duration:\t\t" + getLong(DURATION));
141 | android.util.Log.i("Vitamio[Metadata]", "length:\t\t" + getLong(LENGTH));
142 | android.util.Log.i("Vitamio[Metadata]", "bit_rate:\t\t" + getInt(BIT_RATE));
143 | android.util.Log.i("Vitamio[Metadata]", "audio_bit_rate:\t" + getInt(AUDIO_BIT_RATE));
144 | android.util.Log.i("Vitamio[Metadata]", "video_bit_rate:\t" + getInt(VIDEO_BIT_RATE));
145 | android.util.Log.i("Vitamio[Metadata]", "audio_sample_rate:\t" + getInt(AUDIO_SAMPLE_RATE));
146 | android.util.Log.i("Vitamio[Metadata]", "video_frame_rate:\t" + getDouble(VIDEO_FRAME_RATE));
147 | android.util.Log.i("Vitamio[Metadata]", "format:\t\t" + getString(MIME_TYPE));
148 | android.util.Log.i("Vitamio[Metadata]", "audio_codec:\t" + getString(AUDIO_CODEC));
149 | android.util.Log.i("Vitamio[Metadata]", "video_codec:\t" + getString(VIDEO_CODEC));
150 | android.util.Log.i("Vitamio[Metadata]", "video_height:\t" + getInt(VIDEO_HEIGHT));
151 | android.util.Log.i("Vitamio[Metadata]", "video_width:\t" + getInt(VIDEO_WIDTH));
152 | android.util.Log.i("Vitamio[Metadata]", "num_tracks:\t\t" + getInt(NUM_TRACKS));
153 | android.util.Log.i("Vitamio[Metadata]", "cap_pause:\t\t" + getBoolean(PAUSE_AVAILABLE));
154 | android.util.Log.i("Vitamio[Metadata]", "cap_seek:\t\t" + getBoolean(SEEK_AVAILABLE));
155 | }
156 |
157 | return true;
158 | }
159 |
160 | public boolean has(final int metadataId) {
161 | if (!checkMetadataId(metadataId)) {
162 | throw new IllegalArgumentException("Invalid key: " + metadataId);
163 | }
164 | return mMeta.indexOfKey(metadataId) >= 0;
165 | }
166 |
167 | public String getString(final int key) {
168 | byte[] value = mMeta.get(key);
169 | if (value == null) {
170 | return null;
171 | }
172 | try {
173 | return new String(value, mEncoding);
174 | } catch (UnsupportedEncodingException e) {
175 | return new String(value);
176 | }
177 | }
178 |
179 | public int getInt(final int key) {
180 | try {
181 | return Integer.parseInt(getString(key));
182 | } catch (Exception e) {
183 | return -1;
184 | }
185 | }
186 |
187 | public boolean getBoolean(final int key) {
188 | try {
189 | return Boolean.parseBoolean(getString(key));
190 | } catch (Exception e) {
191 | return false;
192 | }
193 | }
194 |
195 | public long getLong(final int key) {
196 | try {
197 | return Long.parseLong(getString(key));
198 | } catch (Exception e) {
199 | return -1;
200 | }
201 | }
202 |
203 | public double getDouble(final int key) {
204 | try {
205 | return Double.parseDouble(getString(key));
206 | } catch (Exception e) {
207 | return -1;
208 | }
209 | }
210 |
211 | public byte[] getByteArray(final int key) {
212 | return mMeta.get(key);
213 | }
214 |
215 | private boolean checkMetadataId(final int val) {
216 | return !(val <= ANY || (LAST_SYSTEM < val && val < FIRST_CUSTOM));
217 | }
218 | }
219 |
--------------------------------------------------------------------------------
/vitamio/src/io/vov/vitamio/ThumbnailUtils.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2006 The Android Open Source Project
3 | * Copyright (C) 2013 YIXIA.COM
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 io.vov.vitamio;
19 |
20 | import android.content.Context;
21 | import android.graphics.Bitmap;
22 | import android.graphics.Canvas;
23 | import android.graphics.Matrix;
24 | import android.graphics.Rect;
25 |
26 | import io.vov.vitamio.provider.MediaStore.Video;
27 |
28 | /**
29 | * ThumbnailUtils is a wrapper of MediaMetadataRetriever to retrive a thumbnail
30 | * of video file.
31 | *
32 | *
33 | * Bitmap thumb = ThumbnailUtils.createVideoThumbnail(this, videoPath, MINI_KIND);
34 | *
35 | */
36 | public class ThumbnailUtils {
37 | public static final int OPTIONS_RECYCLE_INPUT = 0x2;
38 | public static final int TARGET_SIZE_MINI_THUMBNAIL_WIDTH = 426;
39 | public static final int TARGET_SIZE_MINI_THUMBNAIL_HEIGHT = 320;
40 | public static final int TARGET_SIZE_MICRO_THUMBNAIL_WIDTH = 212;
41 | public static final int TARGET_SIZE_MICRO_THUMBNAIL_HEIGHT = 160;
42 | private static final int OPTIONS_NONE = 0x0;
43 | private static final int OPTIONS_SCALE_UP = 0x1;
44 |
45 | public static Bitmap createVideoThumbnail(Context ctx, String filePath, int kind) {
46 | if (!Vitamio.isInitialized(ctx)) {
47 | return null;
48 | }
49 | Bitmap bitmap = null;
50 | MediaMetadataRetriever retriever = null;
51 | try {
52 | retriever = new MediaMetadataRetriever(ctx);
53 | retriever.setDataSource(filePath);
54 | bitmap = retriever.getFrameAtTime(-1);
55 | } catch (Exception ex) {
56 | } finally {
57 | try {
58 | retriever.release();
59 | } catch (RuntimeException ex) {
60 | }
61 | }
62 |
63 | if (bitmap != null) {
64 | if (kind == Video.Thumbnails.MICRO_KIND)
65 | bitmap = extractThumbnail(bitmap, TARGET_SIZE_MICRO_THUMBNAIL_WIDTH, TARGET_SIZE_MICRO_THUMBNAIL_HEIGHT, OPTIONS_RECYCLE_INPUT);
66 | else if (kind == Video.Thumbnails.MINI_KIND)
67 | bitmap = extractThumbnail(bitmap, TARGET_SIZE_MINI_THUMBNAIL_WIDTH, TARGET_SIZE_MINI_THUMBNAIL_HEIGHT, OPTIONS_RECYCLE_INPUT);
68 | }
69 | return bitmap;
70 | }
71 |
72 | public static Bitmap extractThumbnail(Bitmap source, int width, int height) {
73 | return extractThumbnail(source, width, height, OPTIONS_NONE);
74 | }
75 |
76 | public static Bitmap extractThumbnail(Bitmap source, int width, int height, int options) {
77 | if (source == null)
78 | return null;
79 |
80 | float scale;
81 | if (source.getWidth() < source.getHeight())
82 | scale = width / (float) source.getWidth();
83 | else
84 | scale = height / (float) source.getHeight();
85 | Matrix matrix = new Matrix();
86 | matrix.setScale(scale, scale);
87 | Bitmap thumbnail = transform(matrix, source, width, height, OPTIONS_SCALE_UP | options);
88 | return thumbnail;
89 | }
90 |
91 | private static Bitmap transform(Matrix scaler, Bitmap source, int targetWidth, int targetHeight, int options) {
92 | boolean scaleUp = (options & OPTIONS_SCALE_UP) != 0;
93 | boolean recycle = (options & OPTIONS_RECYCLE_INPUT) != 0;
94 |
95 | int deltaX = source.getWidth() - targetWidth;
96 | int deltaY = source.getHeight() - targetHeight;
97 | if (!scaleUp && (deltaX < 0 || deltaY < 0)) {
98 | Bitmap b2 = Bitmap.createBitmap(targetWidth, targetHeight, Bitmap.Config.ARGB_8888);
99 | Canvas c = new Canvas(b2);
100 |
101 | int deltaXHalf = Math.max(0, deltaX / 2);
102 | int deltaYHalf = Math.max(0, deltaY / 2);
103 | Rect src = new Rect(deltaXHalf, deltaYHalf, deltaXHalf + Math.min(targetWidth, source.getWidth()), deltaYHalf + Math.min(targetHeight, source.getHeight()));
104 | int dstX = (targetWidth - src.width()) / 2;
105 | int dstY = (targetHeight - src.height()) / 2;
106 | Rect dst = new Rect(dstX, dstY, targetWidth - dstX, targetHeight - dstY);
107 | c.drawBitmap(source, src, dst, null);
108 | if (recycle)
109 | source.recycle();
110 | return b2;
111 | }
112 |
113 | float bitmapWidthF = source.getWidth();
114 | float bitmapHeightF = source.getHeight();
115 | float bitmapAspect = bitmapWidthF / bitmapHeightF;
116 | float viewAspect = (float) targetWidth / targetHeight;
117 |
118 | float scale = bitmapAspect > viewAspect ? targetHeight / bitmapHeightF : targetWidth / bitmapWidthF;
119 | if (scale < .9F || scale > 1F)
120 | scaler.setScale(scale, scale);
121 | else
122 | scaler = null;
123 |
124 | Bitmap b1;
125 | if (scaler != null)
126 | b1 = Bitmap.createBitmap(source, 0, 0, source.getWidth(), source.getHeight(), scaler, true);
127 | else
128 | b1 = source;
129 |
130 | if (recycle && b1 != source)
131 | source.recycle();
132 |
133 | int dx1 = Math.max(0, b1.getWidth() - targetWidth);
134 | int dy1 = Math.max(0, b1.getHeight() - targetHeight);
135 |
136 | Bitmap b2 = Bitmap.createBitmap(b1, dx1 / 2, dy1 / 2, targetWidth, targetHeight);
137 |
138 | if (b2 != b1 && (recycle || b1 != source))
139 | b1.recycle();
140 |
141 | return b2;
142 | }
143 |
144 | }
--------------------------------------------------------------------------------
/vitamio/src/io/vov/vitamio/VIntent.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2013 YIXIA.COM
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 |
17 | package io.vov.vitamio;
18 |
19 | /**
20 | * Common intent actions used by Vitamio component.
21 | */
22 | public class VIntent {
23 | public static final String ACTION_MEDIA_SCANNER_SCAN_DIRECTORY = "com.yixia.vitamio.action.MEDIA_SCANNER_SCAN_DIRECTORY";
24 | public static final String ACTION_MEDIA_SCANNER_SCAN_FILE = "com.yixia.vitamio.action.MEDIA_SCANNER_SCAN_FILE";
25 | public static final String ACTION_MEDIA_SCANNER_STARTED = "com.yixia.vitamio.action.MEDIA_SCANNER_STARTED";
26 | public static final String ACTION_MEDIA_SCANNER_FINISHED = "com.yixia.vitamio.action.MEDIA_SCANNER_FINISHED";
27 | }
28 |
--------------------------------------------------------------------------------
/vitamio/src/io/vov/vitamio/VitamioLicense.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2013 YIXIA.COM
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 |
17 | package io.vov.vitamio;
18 |
19 | /**
20 | * DON'T MODIFY THIS FILE IF YOU WANT TO USE VITAMIO
21 | */
22 | public class VitamioLicense {
23 | public static final String LICENSE = "Copyright (c) YIXIA (http://yixia.com).\nTHIS SOFTWARE (Vitamio) IS WORK OF YIXIA (http://yixia.com)";
24 | }
--------------------------------------------------------------------------------
/vitamio/src/io/vov/vitamio/activity/InitActivity.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2013 YIXIA.COM
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 |
17 | package io.vov.vitamio.activity;
18 |
19 | import android.app.Activity;
20 | import android.app.ProgressDialog;
21 | import android.content.Context;
22 | import android.content.Intent;
23 | import android.os.AsyncTask;
24 | import android.os.Bundle;
25 | import android.os.Handler;
26 | import android.os.Message;
27 | import android.view.WindowManager;
28 |
29 | import java.lang.ref.WeakReference;
30 |
31 | import io.vov.vitamio.R;
32 | import io.vov.vitamio.Vitamio;
33 |
34 | public class InitActivity extends Activity {
35 | public static final String FROM_ME = "fromVitamioInitActivity";
36 | private ProgressDialog mPD;
37 | private UIHandler uiHandler;
38 |
39 | protected void onCreate(Bundle savedInstanceState) {
40 | super.onCreate(savedInstanceState);
41 | getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
42 | uiHandler = new UIHandler(this);
43 |
44 | new AsyncTask() {
45 | @Override
46 | protected void onPreExecute() {
47 | mPD = new ProgressDialog(InitActivity.this);
48 | mPD.setCancelable(false);
49 | mPD.setMessage(InitActivity.this.getString(R.string.vitamio_init_decoders));
50 | mPD.show();
51 | }
52 |
53 | @Override
54 | protected Boolean doInBackground(Object... params) {
55 | return Vitamio.initialize(InitActivity.this, R.raw.libarm);
56 | }
57 |
58 | @Override
59 | protected void onPostExecute(Boolean inited) {
60 | if (inited) {
61 | uiHandler.sendEmptyMessage(0);
62 | }
63 | }
64 |
65 | }.execute();
66 | }
67 |
68 | private static class UIHandler extends Handler {
69 | private WeakReference mContext;
70 |
71 | public UIHandler(Context c) {
72 | mContext = new WeakReference(c);
73 | }
74 |
75 | public void handleMessage(Message msg) {
76 | InitActivity ctx = (InitActivity) mContext.get();
77 | switch (msg.what) {
78 | case 0:
79 | ctx.mPD.dismiss();
80 | Intent src = ctx.getIntent();
81 | Intent i = new Intent();
82 | i.setClassName(src.getStringExtra("package"), src.getStringExtra("className"));
83 | i.setData(src.getData());
84 | i.putExtras(src);
85 | i.putExtra(FROM_ME, true);
86 | ctx.startActivity(i);
87 | ctx.finish();
88 | break;
89 | }
90 | }
91 | }
92 | }
93 |
--------------------------------------------------------------------------------
/vitamio/src/io/vov/vitamio/provider/MiniThumbFile.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2006 The Android Open Source Project
3 | * Copyright (C) 2013 YIXIA.COM
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 io.vov.vitamio.provider;
19 |
20 | import android.net.Uri;
21 | import android.os.Environment;
22 |
23 | import java.io.File;
24 | import java.io.IOException;
25 | import java.io.RandomAccessFile;
26 | import java.nio.ByteBuffer;
27 | import java.nio.channels.FileChannel;
28 | import java.nio.channels.FileLock;
29 | import java.util.Hashtable;
30 |
31 | import io.vov.vitamio.provider.MediaStore.Video;
32 | import io.vov.vitamio.utils.Log;
33 |
34 | public class MiniThumbFile {
35 | protected static final int BYTES_PER_MINTHUMB = 10000;
36 | private static final int MINI_THUMB_DATA_FILE_VERSION = 7;
37 | private static final int HEADER_SIZE = 1 + 8 + 4;
38 | private static Hashtable sThumbFiles = new Hashtable();
39 | private Uri mUri;
40 | private RandomAccessFile mMiniThumbFile;
41 | private FileChannel mChannel;
42 | private ByteBuffer mBuffer;
43 |
44 | public MiniThumbFile(Uri uri) {
45 | mUri = uri;
46 | mBuffer = ByteBuffer.allocateDirect(BYTES_PER_MINTHUMB);
47 | }
48 |
49 | protected static synchronized void reset() {
50 | for (MiniThumbFile file : sThumbFiles.values())
51 | file.deactivate();
52 | sThumbFiles.clear();
53 | }
54 |
55 | protected static synchronized MiniThumbFile instance(Uri uri) {
56 | String type = uri.getPathSegments().get(0);
57 | MiniThumbFile file = sThumbFiles.get(type);
58 | if (file == null) {
59 | file = new MiniThumbFile(Uri.parse(MediaStore.CONTENT_AUTHORITY_SLASH + type + "/media"));
60 | sThumbFiles.put(type, file);
61 | }
62 |
63 | return file;
64 | }
65 |
66 | private String randomAccessFilePath(int version) {
67 | String directoryName = Environment.getExternalStorageDirectory().toString() + "/" + Video.Thumbnails.THUMBNAILS_DIRECTORY;
68 | return directoryName + "/.thumbdata" + version + "-" + mUri.hashCode();
69 | }
70 |
71 | private void removeOldFile() {
72 | String oldPath = randomAccessFilePath(MINI_THUMB_DATA_FILE_VERSION - 1);
73 | File oldFile = new File(oldPath);
74 | if (oldFile.exists()) {
75 | try {
76 | oldFile.delete();
77 | } catch (SecurityException ex) {
78 | }
79 | }
80 | }
81 |
82 | private RandomAccessFile miniThumbDataFile() {
83 | if (mMiniThumbFile == null) {
84 | removeOldFile();
85 | String path = randomAccessFilePath(MINI_THUMB_DATA_FILE_VERSION);
86 | File directory = new File(path).getParentFile();
87 | if (!directory.isDirectory()) {
88 | if (!directory.mkdirs())
89 | Log.e("Unable to create .thumbnails directory %s", directory.toString());
90 | }
91 | File f = new File(path);
92 | try {
93 | mMiniThumbFile = new RandomAccessFile(f, "rw");
94 | } catch (IOException ex) {
95 | try {
96 | mMiniThumbFile = new RandomAccessFile(f, "r");
97 | } catch (IOException ex2) {
98 | }
99 | }
100 |
101 | if (mMiniThumbFile != null)
102 | mChannel = mMiniThumbFile.getChannel();
103 | }
104 | return mMiniThumbFile;
105 | }
106 |
107 | protected synchronized void deactivate() {
108 | if (mMiniThumbFile != null) {
109 | try {
110 | mMiniThumbFile.close();
111 | mMiniThumbFile = null;
112 | } catch (IOException ex) {
113 | }
114 | }
115 | }
116 |
117 | protected synchronized long getMagic(long id) {
118 | RandomAccessFile r = miniThumbDataFile();
119 | if (r != null) {
120 | long pos = id * BYTES_PER_MINTHUMB;
121 | FileLock lock = null;
122 | try {
123 | mBuffer.clear();
124 | mBuffer.limit(1 + 8);
125 |
126 | lock = mChannel.lock(pos, 1 + 8, true);
127 | if (mChannel.read(mBuffer, pos) == 9) {
128 | mBuffer.position(0);
129 | if (mBuffer.get() == 1)
130 | return mBuffer.getLong();
131 | }
132 | } catch (IOException ex) {
133 | Log.e("Got exception checking file magic: ", ex);
134 | } catch (RuntimeException ex) {
135 | Log.e("Got exception when reading magic, id = %d, disk full or mount read-only? %s", id, ex.getClass().toString());
136 | } finally {
137 | try {
138 | if (lock != null)
139 | lock.release();
140 | } catch (IOException ex) {
141 | }
142 | }
143 | }
144 | return 0;
145 | }
146 |
147 | protected synchronized void saveMiniThumbToFile(byte[] data, long id, long magic) throws IOException {
148 | RandomAccessFile r = miniThumbDataFile();
149 | if (r == null)
150 | return;
151 |
152 | long pos = id * BYTES_PER_MINTHUMB;
153 | FileLock lock = null;
154 | try {
155 | if (data != null) {
156 | if (data.length > BYTES_PER_MINTHUMB - HEADER_SIZE)
157 | return;
158 |
159 | mBuffer.clear();
160 | mBuffer.put((byte) 1);
161 | mBuffer.putLong(magic);
162 | mBuffer.putInt(data.length);
163 | mBuffer.put(data);
164 | mBuffer.flip();
165 |
166 | lock = mChannel.lock(pos, BYTES_PER_MINTHUMB, false);
167 | mChannel.write(mBuffer, pos);
168 | }
169 | } catch (IOException ex) {
170 | Log.e("couldn't save mini thumbnail data for %d; %s", id, ex.getMessage());
171 | throw ex;
172 | } catch (RuntimeException ex) {
173 | Log.e("couldn't save mini thumbnail data for %d, disk full or mount read-only? %s", id, ex.getClass().toString());
174 | } finally {
175 | try {
176 | if (lock != null)
177 | lock.release();
178 | } catch (IOException ex) {
179 | }
180 | }
181 | }
182 |
183 | protected synchronized byte[] getMiniThumbFromFile(long id, byte[] data) {
184 | RandomAccessFile r = miniThumbDataFile();
185 | if (r == null)
186 | return null;
187 |
188 | long pos = id * BYTES_PER_MINTHUMB;
189 | FileLock lock = null;
190 | try {
191 | mBuffer.clear();
192 | lock = mChannel.lock(pos, BYTES_PER_MINTHUMB, true);
193 | int size = mChannel.read(mBuffer, pos);
194 | if (size > 1 + 8 + 4) {
195 | mBuffer.position(9);
196 | int length = mBuffer.getInt();
197 |
198 | if (size >= 1 + 8 + 4 + length && data.length >= length) {
199 | mBuffer.get(data, 0, length);
200 | return data;
201 | }
202 | }
203 | } catch (IOException ex) {
204 | Log.e("got exception when reading thumbnail id = %d, exception: %s", id, ex.getMessage());
205 | } catch (RuntimeException ex) {
206 | Log.e("Got exception when reading thumbnail, id = %d, disk full or mount read-only? %s", id, ex.getClass().toString());
207 | } finally {
208 | try {
209 | if (lock != null)
210 | lock.release();
211 | } catch (IOException ex) {
212 | }
213 | }
214 | return null;
215 | }
216 | }
--------------------------------------------------------------------------------
/vitamio/src/io/vov/vitamio/utils/CPU.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2012 YIXIA.COM
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 | package io.vov.vitamio.utils;
17 |
18 | import android.os.Build;
19 | import android.text.TextUtils;
20 |
21 | import java.io.BufferedReader;
22 | import java.io.File;
23 | import java.io.FileReader;
24 | import java.io.IOException;
25 | import java.util.HashMap;
26 | import java.util.Map;
27 |
28 | public class CPU {
29 | public static final int FEATURE_ARM_V5TE = 1 << 0;
30 | public static final int FEATURE_ARM_V6 = 1 << 1;
31 | public static final int FEATURE_ARM_VFP = 1 << 2;
32 | public static final int FEATURE_ARM_V7A = 1 << 3;
33 | public static final int FEATURE_ARM_VFPV3 = 1 << 4;
34 | public static final int FEATURE_ARM_NEON = 1 << 5;
35 | public static final int FEATURE_X86 = 1 << 6;
36 | public static final int FEATURE_MIPS = 1 << 7;
37 | private static final Map cpuinfo = new HashMap();
38 | private static int cachedFeature = -1;
39 | private static String cachedFeatureString = null;
40 |
41 | public static String getFeatureString() {
42 | getFeature();
43 | return cachedFeatureString;
44 | }
45 |
46 | public static int getFeature() {
47 | if (cachedFeature > 0)
48 | return getCachedFeature();
49 |
50 | cachedFeature = FEATURE_ARM_V5TE;
51 |
52 | if (cpuinfo.isEmpty()) {
53 | BufferedReader bis = null;
54 | try {
55 | bis = new BufferedReader(new FileReader(new File("/proc/cpuinfo")));
56 | String line;
57 | String[] pairs;
58 | while ((line = bis.readLine()) != null) {
59 | if (!line.trim().equals("")) {
60 | pairs = line.split(":");
61 | if (pairs.length > 1)
62 | cpuinfo.put(pairs[0].trim(), pairs[1].trim());
63 | }
64 | }
65 | } catch (Exception e) {
66 | Log.e("getCPUFeature", e);
67 | } finally {
68 | try {
69 | if (bis != null)
70 | bis.close();
71 | } catch (IOException e) {
72 | Log.e("getCPUFeature", e);
73 | }
74 | }
75 | }
76 |
77 | if (!cpuinfo.isEmpty()) {
78 | for (String key : cpuinfo.keySet())
79 | Log.d("%s:%s", key, cpuinfo.get(key));
80 |
81 | boolean hasARMv6 = false;
82 | boolean hasARMv7 = false;
83 |
84 | String val = cpuinfo.get("CPU architecture");
85 | if (!TextUtils.isEmpty(val)) {
86 | try {
87 | int i = StringUtils.convertToInt(val);
88 | Log.d("CPU architecture: %s", i);
89 | if (i >= 7) {
90 | hasARMv6 = true;
91 | hasARMv7 = true;
92 | } else if (i >= 6) {
93 | hasARMv6 = true;
94 | hasARMv7 = false;
95 | }
96 | } catch (NumberFormatException ex) {
97 | Log.e("getCPUFeature", ex);
98 | }
99 |
100 | val = cpuinfo.get("Processor");
101 | if (val != null && (val.contains("(v7l)") || val.contains("ARMv7"))) {
102 | hasARMv6 = true;
103 | hasARMv7 = true;
104 | }
105 | if (val != null && (val.contains("(v6l)") || val.contains("ARMv6"))) {
106 | hasARMv6 = true;
107 | hasARMv7 = false;
108 | }
109 |
110 | if (hasARMv6)
111 | cachedFeature |= FEATURE_ARM_V6;
112 | if (hasARMv7)
113 | cachedFeature |= FEATURE_ARM_V7A;
114 |
115 | val = cpuinfo.get("Features");
116 | if (val != null) {
117 | if (val.contains("neon"))
118 | cachedFeature |= FEATURE_ARM_VFP | FEATURE_ARM_VFPV3 | FEATURE_ARM_NEON;
119 | else if (val.contains("vfpv3"))
120 | cachedFeature |= FEATURE_ARM_VFP | FEATURE_ARM_VFPV3;
121 | else if (val.contains("vfp"))
122 | cachedFeature |= FEATURE_ARM_VFP;
123 | }
124 | } else {
125 | String vendor_id = cpuinfo.get("vendor_id");
126 | String mips = cpuinfo.get("cpu model");
127 | if (!TextUtils.isEmpty(vendor_id) && vendor_id.contains("GenuineIntel")) {
128 | cachedFeature |= FEATURE_X86;
129 | } else if (!TextUtils.isEmpty(mips) && mips.contains("MIPS")) {
130 | cachedFeature |= FEATURE_MIPS;
131 | }
132 | }
133 | }
134 |
135 | return getCachedFeature();
136 | }
137 |
138 | private static int getCachedFeature() {
139 | if (cachedFeatureString == null) {
140 | StringBuffer sb = new StringBuffer();
141 | if ((cachedFeature & FEATURE_ARM_V5TE) > 0)
142 | sb.append("V5TE ");
143 | if ((cachedFeature & FEATURE_ARM_V6) > 0)
144 | sb.append("V6 ");
145 | if ((cachedFeature & FEATURE_ARM_VFP) > 0)
146 | sb.append("VFP ");
147 | if ((cachedFeature & FEATURE_ARM_V7A) > 0)
148 | sb.append("V7A ");
149 | if ((cachedFeature & FEATURE_ARM_VFPV3) > 0)
150 | sb.append("VFPV3 ");
151 | if ((cachedFeature & FEATURE_ARM_NEON) > 0)
152 | sb.append("NEON ");
153 | if ((cachedFeature & FEATURE_X86) > 0)
154 | sb.append("X86 ");
155 | if ((cachedFeature & FEATURE_MIPS) > 0)
156 | sb.append("MIPS ");
157 | cachedFeatureString = sb.toString();
158 | }
159 | Log.d("GET CPU FATURE: %s", cachedFeatureString);
160 | return cachedFeature;
161 | }
162 |
163 | public static boolean isDroidXDroid2() {
164 | return (Build.MODEL.trim().equalsIgnoreCase("DROIDX") || Build.MODEL.trim().equalsIgnoreCase("DROID2") || Build.FINGERPRINT.toLowerCase().contains("shadow") || Build.FINGERPRINT.toLowerCase().contains("droid2"));
165 | }
166 | }
167 |
--------------------------------------------------------------------------------
/vitamio/src/io/vov/vitamio/utils/ContextUtils.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2012 YIXIA.COM
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 | package io.vov.vitamio.utils;
17 |
18 | import android.content.Context;
19 | import android.content.pm.ApplicationInfo;
20 |
21 | public class ContextUtils {
22 | public static int getVersionCode(Context ctx) {
23 | int version = 0;
24 | try {
25 | version = ctx.getPackageManager().getPackageInfo(ctx.getApplicationInfo().packageName, 0).versionCode;
26 | } catch (Exception e) {
27 | Log.e("getVersionInt", e);
28 | }
29 | return version;
30 | }
31 |
32 | public static String getDataDir(Context ctx) {
33 | ApplicationInfo ai = ctx.getApplicationInfo();
34 | if (ai.dataDir != null)
35 | return fixLastSlash(ai.dataDir);
36 | else
37 | return "/data/data/" + ai.packageName + "/";
38 | }
39 |
40 | public static String fixLastSlash(String str) {
41 | String res = str == null ? "/" : str.trim() + "/";
42 | if (res.length() > 2 && res.charAt(res.length() - 2) == '/')
43 | res = res.substring(0, res.length() - 1);
44 | return res;
45 | }
46 | }
47 |
--------------------------------------------------------------------------------
/vitamio/src/io/vov/vitamio/utils/Crypto.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2012 YIXIA.COM
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 | package io.vov.vitamio.utils;
17 |
18 | import java.io.BufferedInputStream;
19 | import java.io.IOException;
20 | import java.io.InputStream;
21 | import java.io.ObjectInputStream;
22 | import java.io.UnsupportedEncodingException;
23 | import java.math.BigInteger;
24 | import java.security.MessageDigest;
25 | import java.security.PublicKey;
26 | import java.security.spec.AlgorithmParameterSpec;
27 |
28 | import javax.crypto.Cipher;
29 | import javax.crypto.SecretKey;
30 | import javax.crypto.spec.IvParameterSpec;
31 | import javax.crypto.spec.SecretKeySpec;
32 |
33 | public class Crypto {
34 | private Cipher ecipher;
35 |
36 | public Crypto(String key) {
37 | try {
38 | SecretKeySpec skey = new SecretKeySpec(generateKey(key), "AES");
39 | setupCrypto(skey);
40 | } catch (Exception e) {
41 | Log.e("Crypto", e);
42 | }
43 | }
44 |
45 | public static String md5(String plain) {
46 | try {
47 | MessageDigest m = MessageDigest.getInstance("MD5");
48 | m.update(plain.getBytes());
49 | byte[] digest = m.digest();
50 | BigInteger bigInt = new BigInteger(1, digest);
51 | String hashtext = bigInt.toString(16);
52 | while (hashtext.length() < 32) {
53 | hashtext = "0" + hashtext;
54 | }
55 | return hashtext;
56 | } catch (Exception e) {
57 | return "";
58 | }
59 | }
60 |
61 | private static byte[] generateKey(String input) {
62 | try {
63 | byte[] bytesOfMessage = input.getBytes("UTF-8");
64 | MessageDigest md = MessageDigest.getInstance("SHA256");
65 | return md.digest(bytesOfMessage);
66 | } catch (Exception e) {
67 | Log.e("generateKey", e);
68 | return null;
69 | }
70 | }
71 |
72 | private void setupCrypto(SecretKey key) {
73 | byte[] iv = new byte[]{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};
74 | AlgorithmParameterSpec paramSpec = new IvParameterSpec(iv);
75 | try {
76 | ecipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
77 | ecipher.init(Cipher.ENCRYPT_MODE, key, paramSpec);
78 | } catch (Exception e) {
79 | ecipher = null;
80 | Log.e("setupCrypto", e);
81 | }
82 | }
83 |
84 | public String encrypt(String plaintext) {
85 | if (ecipher == null)
86 | return "";
87 |
88 | try {
89 | byte[] ciphertext = ecipher.doFinal(plaintext.getBytes("UTF-8"));
90 | return Base64.encodeToString(ciphertext, Base64.NO_WRAP);
91 | } catch (Exception e) {
92 | Log.e("encryp", e);
93 | return "";
94 | }
95 | }
96 |
97 | private PublicKey readKeyFromStream(InputStream keyStream) throws IOException {
98 | ObjectInputStream oin = new ObjectInputStream(new BufferedInputStream(keyStream));
99 | try {
100 | PublicKey pubKey = (PublicKey) oin.readObject();
101 | return pubKey;
102 | } catch (Exception e) {
103 | Log.e("readKeyFromStream", e);
104 | return null;
105 | } finally {
106 | oin.close();
107 | }
108 | }
109 |
110 | public String rsaEncrypt(InputStream keyStream, String data) {
111 | try {
112 | return rsaEncrypt(keyStream, data.getBytes("UTF-8"));
113 | } catch (UnsupportedEncodingException e) {
114 | return "";
115 | }
116 | }
117 |
118 | public String rsaEncrypt(InputStream keyStream, byte[] data) {
119 | try {
120 | PublicKey pubKey = readKeyFromStream(keyStream);
121 | Cipher cipher = Cipher.getInstance("RSA/ECB/NoPadding");
122 | cipher.init(Cipher.ENCRYPT_MODE, pubKey);
123 | byte[] cipherData = cipher.doFinal(data);
124 | return Base64.encodeToString(cipherData, Base64.NO_WRAP);
125 | } catch (Exception e) {
126 | Log.e("rsaEncrypt", e);
127 | return "";
128 | }
129 | }
130 |
131 | }
132 |
--------------------------------------------------------------------------------
/vitamio/src/io/vov/vitamio/utils/Device.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2012 YIXIA.COM
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 | package io.vov.vitamio.utils;
17 |
18 | import android.annotation.SuppressLint;
19 | import android.content.Context;
20 | import android.os.Build;
21 | import android.provider.Settings;
22 | import android.telephony.TelephonyManager;
23 | import android.util.DisplayMetrics;
24 |
25 | import java.util.Locale;
26 |
27 | public class Device {
28 | public static String getLocale() {
29 | Locale locale = Locale.getDefault();
30 | if (locale != null) {
31 | String lo = locale.getLanguage();
32 | Log.i("getLocale " + lo);
33 | if (lo != null) {
34 | return lo.toLowerCase();
35 | }
36 | }
37 | return "en";
38 | }
39 |
40 | public static String getDeviceFeatures(Context ctx) {
41 | return getIdentifiers(ctx) + getSystemFeatures() + getScreenFeatures(ctx);
42 | }
43 |
44 | @SuppressLint("NewApi")
45 | public static String getIdentifiers(Context ctx) {
46 | StringBuilder sb = new StringBuilder();
47 | sb.append(getPair("serial", Build.SERIAL));
48 | sb.append(getPair("android_id", Settings.Secure.getString(ctx.getContentResolver(), Settings.Secure.ANDROID_ID)));
49 | TelephonyManager tel = (TelephonyManager) ctx.getSystemService(Context.TELEPHONY_SERVICE);
50 | sb.append(getPair("sim_country_iso", tel.getSimCountryIso()));
51 | sb.append(getPair("network_operator_name", tel.getNetworkOperatorName()));
52 | sb.append(getPair("unique_id", Crypto.md5(sb.toString())));
53 | return sb.toString();
54 | }
55 |
56 | public static String getSystemFeatures() {
57 | StringBuilder sb = new StringBuilder();
58 | sb.append(getPair("android_release", Build.VERSION.RELEASE));
59 | sb.append(getPair("android_sdk_int", "" + Build.VERSION.SDK_INT));
60 | sb.append(getPair("device_cpu_abi", Build.CPU_ABI));
61 | sb.append(getPair("device_model", Build.MODEL));
62 | sb.append(getPair("device_manufacturer", Build.MANUFACTURER));
63 | sb.append(getPair("device_board", Build.BOARD));
64 | sb.append(getPair("device_fingerprint", Build.FINGERPRINT));
65 | sb.append(getPair("device_cpu_feature", CPU.getFeatureString()));
66 | return sb.toString();
67 | }
68 |
69 | public static String getScreenFeatures(Context ctx) {
70 | StringBuilder sb = new StringBuilder();
71 | DisplayMetrics disp = ctx.getResources().getDisplayMetrics();
72 | sb.append(getPair("screen_density", "" + disp.density));
73 | sb.append(getPair("screen_density_dpi", "" + disp.densityDpi));
74 | sb.append(getPair("screen_height_pixels", "" + disp.heightPixels));
75 | sb.append(getPair("screen_width_pixels", "" + disp.widthPixels));
76 | sb.append(getPair("screen_scaled_density", "" + disp.scaledDensity));
77 | sb.append(getPair("screen_xdpi", "" + disp.xdpi));
78 | sb.append(getPair("screen_ydpi", "" + disp.ydpi));
79 | return sb.toString();
80 | }
81 |
82 | private static String getPair(String key, String value) {
83 | key = key == null ? "" : key.trim();
84 | value = value == null ? "" : value.trim();
85 | return "&" + key + "=" + value;
86 | }
87 | }
88 |
--------------------------------------------------------------------------------
/vitamio/src/io/vov/vitamio/utils/FileUtils.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2012 YIXIA.COM
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 | package io.vov.vitamio.utils;
17 |
18 | import android.net.Uri;
19 | import android.text.TextUtils;
20 |
21 | import java.io.File;
22 | import java.io.IOException;
23 |
24 | public class FileUtils {
25 | private static final String FILE_NAME_RESERVED = "|\\?*<\":>+[]/'";
26 |
27 | public static String getUniqueFileName(String name, String id) {
28 | StringBuilder sb = new StringBuilder();
29 | for (Character c : name.toCharArray()) {
30 | if (FILE_NAME_RESERVED.indexOf(c) == -1) {
31 | sb.append(c);
32 | }
33 | }
34 | name = sb.toString();
35 | if (name.length() > 16) {
36 | name = name.substring(0, 16);
37 | }
38 | id = Crypto.md5(id);
39 | name += id;
40 | try {
41 | File f = File.createTempFile(name, null);
42 | if (f.exists()) {
43 | f.delete();
44 | return name;
45 | }
46 | } catch (IOException e) {
47 | }
48 | return id;
49 | }
50 |
51 | public static String getCanonical(File f) {
52 | if (f == null)
53 | return null;
54 |
55 | try {
56 | return f.getCanonicalPath();
57 | } catch (IOException e) {
58 | return f.getAbsolutePath();
59 | }
60 | }
61 |
62 | /**
63 | * Get the path for the file:/// only
64 | *
65 | * @param uri
66 | * @return
67 | */
68 | public static String getPath(String uri) {
69 | Log.i("FileUtils#getPath(%s)", uri);
70 | if (TextUtils.isEmpty(uri))
71 | return null;
72 | if (uri.startsWith("file://") && uri.length() > 7)
73 | return Uri.decode(uri.substring(7));
74 | return Uri.decode(uri);
75 | }
76 |
77 | public static String getName(String uri) {
78 | String path = getPath(uri);
79 | if (path != null)
80 | return new File(path).getName();
81 | return null;
82 | }
83 |
84 | public static void deleteDir(File f) {
85 | if (f.exists() && f.isDirectory()) {
86 | for (File file : f.listFiles()) {
87 | if (file.isDirectory())
88 | deleteDir(file);
89 | file.delete();
90 | }
91 | f.delete();
92 | }
93 | }
94 | }
--------------------------------------------------------------------------------
/vitamio/src/io/vov/vitamio/utils/IOUtils.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2012 YIXIA.COM
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 | package io.vov.vitamio.utils;
17 |
18 | import android.database.Cursor;
19 | import android.os.ParcelFileDescriptor;
20 | import android.util.Log;
21 |
22 | import java.io.Closeable;
23 |
24 | public class IOUtils {
25 |
26 | private static final String TAG = "IOUtils";
27 |
28 | public static void closeSilently(Closeable c) {
29 | if (c == null)
30 | return;
31 | try {
32 | c.close();
33 | } catch (Throwable t) {
34 | Log.w(TAG, "fail to close", t);
35 | }
36 | }
37 |
38 | public static void closeSilently(ParcelFileDescriptor c) {
39 | if (c == null)
40 | return;
41 | try {
42 | c.close();
43 | } catch (Throwable t) {
44 | Log.w(TAG, "fail to close", t);
45 | }
46 | }
47 |
48 | public static void closeSilently(Cursor cursor) {
49 | try {
50 | if (cursor != null) cursor.close();
51 | } catch (Throwable t) {
52 | Log.w(TAG, "fail to close", t);
53 | }
54 | }
55 | }
56 |
--------------------------------------------------------------------------------
/vitamio/src/io/vov/vitamio/utils/Log.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2012 YIXIA.COM
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 | package io.vov.vitamio.utils;
17 |
18 | import java.util.MissingFormatArgumentException;
19 |
20 | public class Log {
21 | public static final String TAG = "Vitamio";
22 | private static final boolean DEBUG = false;
23 |
24 | public static void i(String msg, Object... args) {
25 | // try {
26 | // if (DEBUG)
27 | // android.util.Log.i(TAG, String.format(msg, args));
28 | // } catch (MissingFormatArgumentException e) {
29 | // android.util.Log.e(TAG, "vitamio.Log", e);
30 | // android.util.Log.i(TAG, msg);
31 | // }
32 | }
33 |
34 | public static void d(String msg, Object... args) {
35 | // try {
36 | // if (DEBUG)
37 | // android.util.Log.d(TAG, String.format(msg, args));
38 | // } catch (MissingFormatArgumentException e) {
39 | // android.util.Log.e(TAG, "vitamio.Log", e);
40 | // android.util.Log.d(TAG, msg);
41 | // }
42 | }
43 |
44 | public static void e(String msg, Object... args) {
45 | try {
46 | android.util.Log.e(TAG, String.format(msg, args));
47 | } catch (MissingFormatArgumentException e) {
48 | android.util.Log.e(TAG, "vitamio.Log", e);
49 | android.util.Log.e(TAG, msg);
50 | }
51 | }
52 |
53 | public static void e(String msg, Throwable t) {
54 | android.util.Log.e(TAG, msg, t);
55 | }
56 | }
57 |
--------------------------------------------------------------------------------
/vitamio/src/io/vov/vitamio/utils/StringUtils.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2012 YIXIA.COM
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 | package io.vov.vitamio.utils;
17 |
18 | import java.util.Arrays;
19 | import java.util.Iterator;
20 |
21 | public class StringUtils {
22 | public static String join(Object[] elements, CharSequence separator) {
23 | return join(Arrays.asList(elements), separator);
24 | }
25 |
26 | public static String join(Iterable elements, CharSequence separator) {
27 | StringBuilder builder = new StringBuilder();
28 |
29 | if (elements != null) {
30 | Iterator iter = elements.iterator();
31 | if (iter.hasNext()) {
32 | builder.append(String.valueOf(iter.next()));
33 | while (iter.hasNext()) {
34 | builder.append(separator).append(String.valueOf(iter.next()));
35 | }
36 | }
37 | }
38 |
39 | return builder.toString();
40 | }
41 |
42 | public static String fixLastSlash(String str) {
43 | String res = str == null ? "/" : str.trim() + "/";
44 | if (res.length() > 2 && res.charAt(res.length() - 2) == '/')
45 | res = res.substring(0, res.length() - 1);
46 | return res;
47 | }
48 |
49 | public static int convertToInt(String str) throws NumberFormatException {
50 | int s, e;
51 | for (s = 0; s < str.length(); s++)
52 | if (Character.isDigit(str.charAt(s)))
53 | break;
54 | for (e = str.length(); e > 0; e--)
55 | if (Character.isDigit(str.charAt(e - 1)))
56 | break;
57 | if (e > s) {
58 | try {
59 | return Integer.parseInt(str.substring(s, e));
60 | } catch (NumberFormatException ex) {
61 | Log.e("convertToInt", ex);
62 | throw new NumberFormatException();
63 | }
64 | } else {
65 | throw new NumberFormatException();
66 | }
67 | }
68 |
69 | public static String generateTime(long time) {
70 | int totalSeconds = (int) (time / 1000);
71 | int seconds = totalSeconds % 60;
72 | int minutes = (totalSeconds / 60) % 60;
73 | int hours = totalSeconds / 3600;
74 |
75 | return hours > 0 ? String.format("%02d:%02d:%02d", hours, minutes, seconds) : String.format("%02d:%02d", minutes, seconds);
76 | }
77 |
78 | }
79 |
--------------------------------------------------------------------------------
/vitamio/src/io/vov/vitamio/widget/CenterLayout.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2013 YIXIA.COM
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 |
17 | package io.vov.vitamio.widget;
18 |
19 | import android.content.Context;
20 | import android.util.AttributeSet;
21 | import android.view.View;
22 | import android.view.ViewGroup;
23 | import android.widget.RemoteViews.RemoteView;
24 |
25 | @RemoteView
26 | public class CenterLayout extends ViewGroup {
27 | private int mPaddingLeft = 0;
28 | private int mPaddingRight = 0;
29 | private int mPaddingTop = 0;
30 | private int mPaddingBottom = 0;
31 | private int mWidth, mHeight;
32 |
33 | public CenterLayout(Context context) {
34 | super(context);
35 | }
36 |
37 | public CenterLayout(Context context, AttributeSet attrs) {
38 | super(context, attrs);
39 | }
40 |
41 | public CenterLayout(Context context, AttributeSet attrs, int defStyle) {
42 | super(context, attrs, defStyle);
43 | }
44 |
45 | @Override
46 | protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
47 | int count = getChildCount();
48 |
49 | int maxHeight = 0;
50 | int maxWidth = 0;
51 |
52 | measureChildren(widthMeasureSpec, heightMeasureSpec);
53 |
54 | for (int i = 0; i < count; i++) {
55 | View child = getChildAt(i);
56 | if (child.getVisibility() != GONE) {
57 | int childRight;
58 | int childBottom;
59 |
60 | CenterLayout.LayoutParams lp = (CenterLayout.LayoutParams) child.getLayoutParams();
61 |
62 | childRight = lp.x + child.getMeasuredWidth();
63 | childBottom = lp.y + child.getMeasuredHeight();
64 |
65 | maxWidth = Math.max(maxWidth, childRight);
66 | maxHeight = Math.max(maxHeight, childBottom);
67 | }
68 | }
69 |
70 | maxWidth += mPaddingLeft + mPaddingRight;
71 | maxHeight += mPaddingTop + mPaddingBottom;
72 |
73 | maxHeight = Math.max(maxHeight, getSuggestedMinimumHeight());
74 | maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth());
75 |
76 | setMeasuredDimension(resolveSize(maxWidth, widthMeasureSpec), resolveSize(maxHeight, heightMeasureSpec));
77 | }
78 |
79 | @Override
80 | protected void onLayout(boolean changed, int l, int t, int r, int b) {
81 | int count = getChildCount();
82 | mWidth = getMeasuredWidth();
83 | mHeight = getMeasuredHeight();
84 | for (int i = 0; i < count; i++) {
85 | View child = getChildAt(i);
86 | if (child.getVisibility() != GONE) {
87 | CenterLayout.LayoutParams lp = (CenterLayout.LayoutParams) child.getLayoutParams();
88 | int childLeft = mPaddingLeft + lp.x;
89 | if (lp.width > 0)
90 | childLeft += (int) ((mWidth - lp.width) / 2.0);
91 | else
92 | childLeft += (int) ((mWidth - child.getMeasuredWidth()) / 2.0);
93 | int childTop = mPaddingTop + lp.y;
94 | if (lp.height > 0)
95 | childTop += (int) ((mHeight - lp.height) / 2.0);
96 | else
97 | childTop += (int) ((mHeight - child.getMeasuredHeight()) / 2.0);
98 | child.layout(childLeft, childTop, childLeft + child.getMeasuredWidth(), childTop + child.getMeasuredHeight());
99 | }
100 | }
101 | }
102 |
103 | @Override
104 | protected boolean checkLayoutParams(ViewGroup.LayoutParams p) {
105 | return p instanceof CenterLayout.LayoutParams;
106 | }
107 |
108 | @Override
109 | protected ViewGroup.LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) {
110 | return new LayoutParams(p);
111 | }
112 |
113 | public static class LayoutParams extends ViewGroup.LayoutParams {
114 | public int x;
115 | public int y;
116 |
117 | public LayoutParams(int width, int height, int x, int y) {
118 | super(width, height);
119 | this.x = x;
120 | this.y = y;
121 | }
122 |
123 | public LayoutParams(ViewGroup.LayoutParams source) {
124 | super(source);
125 | }
126 | }
127 | }
128 |
--------------------------------------------------------------------------------
/vitamio/src/io/vov/vitamio/widget/OutlineTextView.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2013 YIXIA.COM
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 |
17 | package io.vov.vitamio.widget;
18 |
19 | import android.content.Context;
20 | import android.graphics.Canvas;
21 | import android.graphics.Paint;
22 | import android.graphics.Typeface;
23 | import android.text.Layout;
24 | import android.text.StaticLayout;
25 | import android.text.TextPaint;
26 | import android.util.AttributeSet;
27 | import android.widget.TextView;
28 |
29 | /**
30 | * Display text with border, use the same XML attrs as
31 | * {@link android.widget.TextView}, except that {@link OutlineTextView} will
32 | * transform the shadow to border
33 | */
34 | public class OutlineTextView extends TextView {
35 | private TextPaint mTextPaint;
36 | private TextPaint mTextPaintOutline;
37 | private String mText = "";
38 | private int mAscent = 0;
39 | private float mBorderSize;
40 | private int mBorderColor;
41 | private int mColor;
42 | private float mSpacingMult = 1.0f;
43 | private float mSpacingAdd = 0;
44 | private boolean mIncludePad = true;
45 |
46 | public OutlineTextView(Context context) {
47 | super(context);
48 | initPaint();
49 | }
50 |
51 | public OutlineTextView(Context context, AttributeSet attrs) {
52 | super(context, attrs);
53 | initPaint();
54 | }
55 |
56 | public OutlineTextView(Context context, AttributeSet attrs, int defStyle) {
57 | super(context, attrs, defStyle);
58 | initPaint();
59 | }
60 |
61 | private void initPaint() {
62 | mTextPaint = new TextPaint();
63 | mTextPaint.setAntiAlias(true);
64 | mTextPaint.setTextSize(getTextSize());
65 | mTextPaint.setColor(mColor);
66 | mTextPaint.setStyle(Paint.Style.FILL);
67 | mTextPaint.setTypeface(getTypeface());
68 |
69 | mTextPaintOutline = new TextPaint();
70 | mTextPaintOutline.setAntiAlias(true);
71 | mTextPaintOutline.setTextSize(getTextSize());
72 | mTextPaintOutline.setColor(mBorderColor);
73 | mTextPaintOutline.setStyle(Paint.Style.STROKE);
74 | mTextPaintOutline.setTypeface(getTypeface());
75 | mTextPaintOutline.setStrokeWidth(mBorderSize);
76 | }
77 |
78 | public void setText(String text) {
79 | super.setText(text);
80 | mText = text.toString();
81 | requestLayout();
82 | invalidate();
83 | }
84 |
85 | public void setTextSize(float size) {
86 | super.setTextSize(size);
87 | requestLayout();
88 | invalidate();
89 | initPaint();
90 | }
91 |
92 | public void setTextColor(int color) {
93 | super.setTextColor(color);
94 | mColor = color;
95 | invalidate();
96 | initPaint();
97 | }
98 |
99 | public void setShadowLayer(float radius, float dx, float dy, int color) {
100 | super.setShadowLayer(radius, dx, dy, color);
101 | mBorderSize = radius;
102 | mBorderColor = color;
103 | requestLayout();
104 | invalidate();
105 | initPaint();
106 | }
107 |
108 | public void setTypeface(Typeface tf, int style) {
109 | super.setTypeface(tf, style);
110 | requestLayout();
111 | invalidate();
112 | initPaint();
113 | }
114 |
115 | public void setTypeface(Typeface tf) {
116 | super.setTypeface(tf);
117 | requestLayout();
118 | invalidate();
119 | initPaint();
120 | }
121 |
122 | @Override
123 | protected void onDraw(Canvas canvas) {
124 | Layout layout = new StaticLayout(getText(), mTextPaintOutline, getWidth(), Layout.Alignment.ALIGN_CENTER, mSpacingMult, mSpacingAdd, mIncludePad);
125 | layout.draw(canvas);
126 | layout = new StaticLayout(getText(), mTextPaint, getWidth(), Layout.Alignment.ALIGN_CENTER, mSpacingMult, mSpacingAdd, mIncludePad);
127 | layout.draw(canvas);
128 | }
129 |
130 | @Override
131 | protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
132 | Layout layout = new StaticLayout(getText(), mTextPaintOutline, measureWidth(widthMeasureSpec), Layout.Alignment.ALIGN_CENTER, mSpacingMult, mSpacingAdd, mIncludePad);
133 | int ex = (int) (mBorderSize * 2 + 1);
134 | setMeasuredDimension(measureWidth(widthMeasureSpec) + ex, measureHeight(heightMeasureSpec) * layout.getLineCount() + ex);
135 | }
136 |
137 | private int measureWidth(int measureSpec) {
138 | int result = 0;
139 | int specMode = MeasureSpec.getMode(measureSpec);
140 | int specSize = MeasureSpec.getSize(measureSpec);
141 |
142 | if (specMode == MeasureSpec.EXACTLY) {
143 | result = specSize;
144 | } else {
145 | result = (int) mTextPaintOutline.measureText(mText) + getPaddingLeft() + getPaddingRight();
146 | if (specMode == MeasureSpec.AT_MOST) {
147 | result = Math.min(result, specSize);
148 | }
149 | }
150 |
151 | return result;
152 | }
153 |
154 | private int measureHeight(int measureSpec) {
155 | int result = 0;
156 | int specMode = MeasureSpec.getMode(measureSpec);
157 | int specSize = MeasureSpec.getSize(measureSpec);
158 |
159 | mAscent = (int) mTextPaintOutline.ascent();
160 | if (specMode == MeasureSpec.EXACTLY) {
161 | result = specSize;
162 | } else {
163 | result = (int) (-mAscent + mTextPaintOutline.descent()) + getPaddingTop() + getPaddingBottom();
164 | if (specMode == MeasureSpec.AT_MOST) {
165 | result = Math.min(result, specSize);
166 | }
167 | }
168 | return result;
169 | }
170 | }
--------------------------------------------------------------------------------
/vitamio/vitamio.iml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 | generateDebugAndroidTestSources
19 | generateDebugSources
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 |
--------------------------------------------------------------------------------