├── .classpath
├── .gitignore
├── .project
├── AndroidManifest.xml
├── LICENSE
├── README.md
├── icon512.xcf
├── libs
    ├── CACHEWORD_LICENSE
    ├── IOCipher-v0.3-2-g926b982.jar
    ├── SQLCIPHER_LICENSE
    ├── android-support-v4.jar
    ├── android-support-v4.jar.properties
    ├── armeabi-v7a
    │   ├── libiocipher.so
    │   ├── libsqlcipher_android.so
    │   ├── libstlport_shared.so
    │   └── sqlfscat
    ├── armeabi
    │   ├── libiocipher.so
    │   ├── libsqlcipher_android.so
    │   ├── libstlport_shared.so
    │   └── sqlfscat
    ├── cachewordlib-v0.1-3-g71cc426-debug.jar
    ├── jcodec.jar
    ├── svg-android.jar
    └── x86
    │   ├── libiocipher.so
    │   ├── libsqlcipher_android.so
    │   ├── libstlport_shared.so
    │   └── sqlfscat
├── project.properties
├── res
    ├── drawable
    │   ├── audio.png
    │   ├── folder.png
    │   ├── ic_action_camera.png
    │   ├── ic_action_secure.png
    │   ├── ic_action_switch_camera.png
    │   ├── ic_action_switch_video.png
    │   ├── ic_action_video.png
    │   ├── ic_launcher.png
    │   ├── jpeg.png
    │   ├── mp4.png
    │   ├── splash.png
    │   ├── text.png
    │   └── videoclip.png
    ├── layout-land
    │   ├── activity_gallery.xml
    │   └── base_camera.xml
    ├── layout
    │   ├── activity_gallery.xml
    │   ├── activity_lock_screen.xml
    │   ├── base_camera.xml
    │   ├── gallery_gridsq.xml
    │   ├── pzsimageview.xml
    │   └── videoview.xml
    ├── menu
    │   └── main.xml
    └── values
    │   ├── colors.xml
    │   └── strings.xml
├── src
    └── info
    │   └── guardianproject
    │       └── iocipher
    │           └── camera
    │               ├── AudioRecorderActivity.java
    │               ├── CameraBaseActivity.java
    │               ├── GalleryActivity.java
    │               ├── LockScreenActivity.java
    │               ├── MediaConstants.java
    │               ├── StillCameraActivity.java
    │               ├── StorageManager.java
    │               ├── VideoCameraActivity.java
    │               ├── encoders
    │                   ├── AACHelper.java
    │                   ├── ImageToH264MP4Encoder.java
    │                   ├── ImageToMJPEGMOVMuxer.java
    │                   ├── ImageToVP8Encoder.java
    │                   └── YUVtoWebmMuxer.java
    │               ├── io
    │                   ├── IOCipherContentProvider.java
    │                   └── IOCipherFileChannelWrapper.java
    │               └── viewer
    │                   ├── ImageViewerActivity.java
    │                   ├── MjpegInputStream.java
    │                   ├── MjpegView.java
    │                   ├── MjpegViewerActivity.java
    │                   ├── PZSImageView.java
    │                   ├── StreamOverHttp.java
    │                   └── VideoViewerActivity.java
└── web_hi_res_512.png


/.classpath:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <classpath>
 3 | 	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
 4 | 	<classpathentry exported="true" kind="con" path="com.android.ide.eclipse.adt.LIBRARIES"/>
 5 | 	<classpathentry kind="src" path="src"/>
 6 | 	<classpathentry kind="src" path="gen"/>
 7 | 	<classpathentry exported="true" kind="con" path="com.android.ide.eclipse.adt.DEPENDENCIES"/>
 8 | 	<classpathentry kind="output" path="bin/classes"/>
 9 | </classpath>
10 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | bin/
2 | gen/
3 | 


--------------------------------------------------------------------------------
/.project:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <projectDescription>
 3 | 	<name>CameraCipherLibrary</name>
 4 | 	<comment></comment>
 5 | 	<projects>
 6 | 	</projects>
 7 | 	<buildSpec>
 8 | 		<buildCommand>
 9 | 			<name>com.android.ide.eclipse.adt.ResourceManagerBuilder</name>
10 | 			<arguments>
11 | 			</arguments>
12 | 		</buildCommand>
13 | 		<buildCommand>
14 | 			<name>com.android.ide.eclipse.adt.PreCompilerBuilder</name>
15 | 			<arguments>
16 | 			</arguments>
17 | 		</buildCommand>
18 | 		<buildCommand>
19 | 			<name>org.eclipse.jdt.core.javabuilder</name>
20 | 			<arguments>
21 | 			</arguments>
22 | 		</buildCommand>
23 | 		<buildCommand>
24 | 			<name>com.android.ide.eclipse.adt.ApkBuilder</name>
25 | 			<arguments>
26 | 			</arguments>
27 | 		</buildCommand>
28 | 	</buildSpec>
29 | 	<natures>
30 | 		<nature>com.android.ide.eclipse.adt.AndroidNature</nature>
31 | 		<nature>org.eclipse.jdt.core.javanature</nature>
32 | 	</natures>
33 | </projectDescription>
34 | 


--------------------------------------------------------------------------------
/AndroidManifest.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  3 |     package="info.guardianproject.iocipher.camera"
  4 |     android:versionCode="201"
  5 |     android:versionName="2.0.1-dev" >
  6 | 
  7 |     <uses-sdk
  8 |         android:minSdkVersion="14"
  9 |         android:targetSdkVersion="19" />
 10 |         <uses-permission android:name="android.permission.CAMERA" />
 11 |         <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
 12 |     	<uses-permission android:name="android.permission.RECORD_AUDIO" />
 13 | <!-- this is a library project; if you want to build the app, you can uncomment the code below -->
 14 | <!--     
 15 |     <application
 16 |         android:icon="@drawable/ic_launcher"
 17 |         android:label="@string/app_name"
 18 |         android:largeHeap="true"
 19 |         android:allowBackup="false"
 20 |         android:theme="@android:style/Theme.Holo"
 21 |          >
 22 |         <activity
 23 |             android:name="info.guardianproject.iocipher.camera.GalleryActivity"
 24 |             android:label="@string/app_name" 
 25 |             android:uiOptions="splitActionBarWhenNarrow"
 26 |             android:icon="@drawable/ic_launcher"
 27 |             >
 28 |             <intent-filter>
 29 |                 <action android:name="android.intent.action.MAIN" />
 30 | 
 31 |                 <category android:name="android.intent.category.LAUNCHER" />
 32 |             </intent-filter>
 33 |             <intent-filter>
 34 |                 <action android:name="android.intent.action.SEND" />
 35 | 
 36 |                 <category android:name="android.intent.category.DEFAULT" />
 37 | 
 38 |                 <data android:mimeType="*/*" />
 39 |             </intent-filter>
 40 |             
 41 |             <intent-filter>
 42 |                 <action android:name="android.media.action.IMAGE_CAPTURE" />
 43 |                 <category android:name="android.intent.category.DEFAULT" />
 44 |             </intent-filter>
 45 |             
 46 |             <intent-filter>
 47 |                 <action android:name="android.media.action.VIDEO_CAPTURE" />
 48 |                 <category android:name="android.intent.category.DEFAULT" />
 49 |             </intent-filter>
 50 |             
 51 |             <intent-filter>                
 52 | 				<action android:name="info.guardianproject.action.SECURE_STILL_IMAGE_CAMERA" />
 53 |                 <category android:name="android.intent.category.DEFAULT" />
 54 |             </intent-filter>
 55 |             <intent-filter>                
 56 | 				<action android:name="info.guardianproject.action.SECURE_VIDEO_CAMERA" />
 57 |                 <category android:name="android.intent.category.DEFAULT" />
 58 |             </intent-filter>
 59 |                 
 60 |             
 61 |             
 62 |             <intent-filter>
 63 |                 <action android:name="android.provider.MediaStore.ACTION_VIDEO_CAPTURE"/>
 64 |                 <category android:name="android.intent.category.DEFAULT" />
 65 |                 <data android:mimeType="*/*" />
 66 |             </intent-filter>
 67 |         </activity>
 68 |         <activity
 69 |             android:name="info.guardianproject.iocipher.camera.LockScreenActivity"
 70 |              android:theme="@android:style/Theme.NoTitleBar"
 71 |            />
 72 |          <activity
 73 |             android:name="info.guardianproject.iocipher.camera.StillCameraActivity"
 74 |             android:label="Secure Selfie"
 75 |                 android:theme="@android:style/Theme.NoTitleBar"/>
 76 | 
 77 |                  <activity
 78 |             android:name="info.guardianproject.iocipher.camera.VideoCameraActivity"
 79 |             android:label="Secure Video (Native)"
 80 |                 android:theme="@android:style/Theme.NoTitleBar"/>                        
 81 |         
 82 |                  <activity
 83 |             android:name="info.guardianproject.iocipher.camera.viewer.ImageViewerActivity"
 84 |             android:label="Secure Selfie Viewer"
 85 |                 android:theme="@android:style/Theme.NoTitleBar"/>
 86 |         
 87 |                   <activity
 88 |             android:name="info.guardianproject.iocipher.camera.viewer.MjpegViewerActivity"            
 89 |                 android:theme="@android:style/Theme.NoTitleBar"/>
 90 |         
 91 |         <provider
 92 |             android:name="info.guardianproject.iocipher.camera.io.IOCipherContentProvider"
 93 |             android:authorities="info.guardianproject.iocipher.camera"
 94 |             android:exported="true"
 95 |             android:multiprocess="true"
 96 |             android:syncable="false"            
 97 |              />
 98 |         
 99 |          <service
100 |             android:name="info.guardianproject.cacheword.CacheWordService"
101 |             android:enabled="true"
102 |             android:exported="false" />
103 |     </application>
104 | -->
105 | </manifest>
106 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | This file contains the license for IOCipher Camera Library "CipherCam".
 2 | 
 3 | For more information about IOCipher, see https://guardianproject.info/code/iocipher
 4 | and this sample library: https://github.com/n8fr8/IOCipherCameraExample
 5 | 
 6 | If you got this file as a part of a larger bundle, there may be other
 7 | license terms that you should be aware of.
 8 | ===============================================================================
 9 | IOCipher Camera Sample is distributed under this license (aka the 3-clause BSD license)
10 | 
11 | Copyright (C) 2014-2014 Nathan Freitas <nathan@guardianproject.info>
12 | 
13 | Redistribution and use in source and binary forms, with or without
14 | modification, are permitted provided that the following conditions are
15 | met:
16 | 
17 |     * Redistributions of source code must retain the above copyright
18 | notice, this list of conditions and the following disclaimer.
19 | 
20 |     * Redistributions in binary form must reproduce the above
21 | copyright notice, this list of conditions and the following disclaimer
22 | in the documentation and/or other materials provided with the
23 | distribution.
24 | 
25 |     * Neither the names of the copyright owners nor the names of its
26 | contributors may be used to endorse or promote products derived from
27 | this software without specific prior written permission.
28 | 
29 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
30 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
31 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
32 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
33 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
34 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
35 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
36 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
37 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
38 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
39 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
40 | 
41 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | 
 2 | Camera Cipher Library
 3 | ================
 4 | 
 5 | This is an library and example app for the IOCipher framework, which provides encrypted virtual disks for Android. 
 6 | 
 7 | This example demonstrates how to capture a still photo (as an in memory byte[] array) directly from the Camera sensor, store that as an encrypted JPEG file directly inside of IOCipher, and then later share that file as a in-memory byte[] or a stream directly from a ContentProvider. It also handles recording video with audio in the same manner, using the MJPEG MP4 Format and Raw PCM audio.
 8 | 
 9 | The example also provides two basic media viewer activities for photos and video. This provides an in-app mechanism for securely displaying media stored in IOCipher, without having to export the media to a file or share it with another app. These are very simple activities for now, but demonstrate the basic premise of how to extract and render media data from IOCipher. 
10 | 
11 | This example also uses the CacheWord library at https://github.com/guardianproject/cacheword to manage keys and passphrases.
12 | 
13 | Finally, all media processing is done using the latest code from JCodec at http://jcodec.org/ 
14 | 
15 | Please report bugs here:
16 | https://dev.guardianproject.info/projects/iocipher/issues
17 | 
18 | Find out all about IOCipher here:
19 | https://guardianproject.info/code/iocipher/
20 | 
21 | We'd like to hear from you if you have included IOCipher in your app!
22 | support@guardianproject.info
23 | 
24 | MjpegView code originally sourced from various samples and threads. More information at:
25 | https://github.com/elleryq/MjpegSample
26 | 
27 | SVG-Android library available at:
28 | https://github.com/pents90/svg-android
29 | 
30 | Some icons courtesy of: http://www.pelfusion.com/
31 | and http://www.iconarchive.com/show/flat-folder-icons-by-pelfusion/Empty-Folder-icon.html
32 | (free for non-commercial use)
33 | 


--------------------------------------------------------------------------------
/icon512.xcf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/icon512.xcf


--------------------------------------------------------------------------------
/libs/CACHEWORD_LICENSE:
--------------------------------------------------------------------------------
 1 | This file contains the license for CacheWord.
 2 | 
 3 | For more information about CacheWord, see https://guardianproject.info/
 4 | 
 5 | If you got this file as a part of a larger bundle, there may be other
 6 | license terms that you should be aware of.
 7 | ===============================================================================
 8 | CacheWord is distributed under this license (aka the 3-clause BSD license)
 9 | 
10 | Copyright (C) 2013-2014 Abel Luck <abel@guardianproject.info>
11 | 
12 | Redistribution and use in source and binary forms, with or without
13 | modification, are permitted provided that the following conditions are
14 | met:
15 | 
16 |     * Redistributions of source code must retain the above copyright
17 | notice, this list of conditions and the following disclaimer.
18 | 
19 |     * Redistributions in binary form must reproduce the above
20 | copyright notice, this list of conditions and the following disclaimer
21 | in the documentation and/or other materials provided with the
22 | distribution.
23 | 
24 |     * Neither the names of the copyright owners nor the names of its
25 | contributors may be used to endorse or promote products derived from
26 | this software without specific prior written permission.
27 | 
28 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
29 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
30 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
31 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
32 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
33 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
34 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
35 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
36 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
37 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
38 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 | 
40 | 


--------------------------------------------------------------------------------
/libs/IOCipher-v0.3-2-g926b982.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/libs/IOCipher-v0.3-2-g926b982.jar


--------------------------------------------------------------------------------
/libs/SQLCIPHER_LICENSE:
--------------------------------------------------------------------------------
 1 | == SQLite Cipher ==
 2 | 
 3 | SQLite Cipher is an SQLite extension that provides transparent 256 bit AES encryption of database files. 
 4 | Pages are encrypted before being written to disk and are decrypted when read back. 
 5 | 
 6 | Encryption is provided by the OpenSSL crypto library.
 7 | 
 8 | SQLite Cipher was initially developed by Stephen Lombardo at Zetetic LLC (sjlombardo@zetetic.net)  to provide 
 9 | the encrypted database layer for Strip, an iPhone data vault and password manager ( http://www.zetetic.net/products/strip ).  
10 | 
11 | The official SQLCipher software site can be found at http://www.zetetic.net/software/sqlcipher
12 | 
13 | Issues or support questions on using SQLCipher should be entered into the GitHub Issue tracker:
14 | 
15 | http://github.com/sjlombardo/sqlcipher/issues
16 | 
17 | Please DO NOT post issues, support questions, or other problems to blog posts about SQLCipher as we do not monitor them frequently.
18 | 
19 |  Copyright (c) 2010 Zetetic LLC
20 |             All rights reserved.
21 |             
22 |             Redistribution and use in source and binary forms, with or without
23 |             modification, are permitted provided that the following conditions are met:
24 |                 * Redistributions of source code must retain the above copyright
25 |                   notice, this list of conditions and the following disclaimer.
26 |                 * Redistributions in binary form must reproduce the above copyright
27 |                   notice, this list of conditions and the following disclaimer in the
28 |                   documentation and/or other materials provided with the distribution.
29 |                 * Neither the name of the ZETETIC LLC nor the
30 |                   names of its contributors may be used to endorse or promote products
31 |                   derived from this software without specific prior written permission.
32 |             
33 |             THIS SOFTWARE IS PROVIDED BY ZETETIC LLC ''AS IS'' AND ANY
34 |             EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
35 |             WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
36 |             DISCLAIMED. IN NO EVENT SHALL ZETETIC LLC BE LIABLE FOR ANY
37 |             DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
38 |             (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
39 |             LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
40 |             ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
41 |             (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
42 |             SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
43 | 


--------------------------------------------------------------------------------
/libs/android-support-v4.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/libs/android-support-v4.jar


--------------------------------------------------------------------------------
/libs/android-support-v4.jar.properties:
--------------------------------------------------------------------------------
1 | src=android-support-v4.jar
2 | doc=/opt/android-sdk/docs/reference
3 | # The String value of 'doc' is handed straight to `new java.io.File()` so it
4 | # is not possible to use variables.  Therefore, change "/opt/android-sdk" to
5 | # the path to your Android SDK, i.e. the value of $ANDROID_HOME or ${sdk.dir}
6 | #
7 | # Here's the relevant source:
8 | # https://android-review.googlesource.com/#/c/35702/3/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/project/LibraryClasspathContainerInitializer.java
9 | 


--------------------------------------------------------------------------------
/libs/armeabi-v7a/libiocipher.so:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/libs/armeabi-v7a/libiocipher.so


--------------------------------------------------------------------------------
/libs/armeabi-v7a/libsqlcipher_android.so:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/libs/armeabi-v7a/libsqlcipher_android.so


--------------------------------------------------------------------------------
/libs/armeabi-v7a/libstlport_shared.so:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/libs/armeabi-v7a/libstlport_shared.so


--------------------------------------------------------------------------------
/libs/armeabi-v7a/sqlfscat:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/libs/armeabi-v7a/sqlfscat


--------------------------------------------------------------------------------
/libs/armeabi/libiocipher.so:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/libs/armeabi/libiocipher.so


--------------------------------------------------------------------------------
/libs/armeabi/libsqlcipher_android.so:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/libs/armeabi/libsqlcipher_android.so


--------------------------------------------------------------------------------
/libs/armeabi/libstlport_shared.so:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/libs/armeabi/libstlport_shared.so


--------------------------------------------------------------------------------
/libs/armeabi/sqlfscat:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/libs/armeabi/sqlfscat


--------------------------------------------------------------------------------
/libs/cachewordlib-v0.1-3-g71cc426-debug.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/libs/cachewordlib-v0.1-3-g71cc426-debug.jar


--------------------------------------------------------------------------------
/libs/jcodec.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/libs/jcodec.jar


--------------------------------------------------------------------------------
/libs/svg-android.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/libs/svg-android.jar


--------------------------------------------------------------------------------
/libs/x86/libiocipher.so:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/libs/x86/libiocipher.so


--------------------------------------------------------------------------------
/libs/x86/libsqlcipher_android.so:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/libs/x86/libsqlcipher_android.so


--------------------------------------------------------------------------------
/libs/x86/libstlport_shared.so:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/libs/x86/libstlport_shared.so


--------------------------------------------------------------------------------
/libs/x86/sqlfscat:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/libs/x86/sqlfscat


--------------------------------------------------------------------------------
/project.properties:
--------------------------------------------------------------------------------
 1 | # This file is automatically generated by Android Tools.
 2 | # Do not modify this file -- YOUR CHANGES WILL BE ERASED!
 3 | #
 4 | # This file must be checked in Version Control Systems.
 5 | #
 6 | # To customize properties used by the Ant build system edit
 7 | # "ant.properties", and override values to adapt the script to your
 8 | # project structure.
 9 | #
10 | # To enable ProGuard to shrink and obfuscate your code, uncomment this (available properties: sdk.dir, user.home):
11 | 
12 | # Project target.
13 | target=android-19
14 | android.library=true
15 | 


--------------------------------------------------------------------------------
/res/drawable/audio.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/res/drawable/audio.png


--------------------------------------------------------------------------------
/res/drawable/folder.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/res/drawable/folder.png


--------------------------------------------------------------------------------
/res/drawable/ic_action_camera.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/res/drawable/ic_action_camera.png


--------------------------------------------------------------------------------
/res/drawable/ic_action_secure.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/res/drawable/ic_action_secure.png


--------------------------------------------------------------------------------
/res/drawable/ic_action_switch_camera.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/res/drawable/ic_action_switch_camera.png


--------------------------------------------------------------------------------
/res/drawable/ic_action_switch_video.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/res/drawable/ic_action_switch_video.png


--------------------------------------------------------------------------------
/res/drawable/ic_action_video.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/res/drawable/ic_action_video.png


--------------------------------------------------------------------------------
/res/drawable/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/res/drawable/ic_launcher.png


--------------------------------------------------------------------------------
/res/drawable/jpeg.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/res/drawable/jpeg.png


--------------------------------------------------------------------------------
/res/drawable/mp4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/res/drawable/mp4.png


--------------------------------------------------------------------------------
/res/drawable/splash.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/res/drawable/splash.png


--------------------------------------------------------------------------------
/res/drawable/text.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/res/drawable/text.png


--------------------------------------------------------------------------------
/res/drawable/videoclip.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/res/drawable/videoclip.png


--------------------------------------------------------------------------------
/res/layout-land/activity_gallery.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <GridView xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     android:id="@+id/gridview"
 4 |     android:layout_width="match_parent"
 5 |     android:layout_height="match_parent"
 6 |     android:columnWidth="120dp"
 7 |     android:numColumns="auto_fit"    
 8 |     android:verticalSpacing="9dp"
 9 |     android:horizontalSpacing="9dp"
10 |     android:stretchMode="columnWidth"
11 |     android:gravity="center"
12 |     android:layout_margin="3dp"
13 | />


--------------------------------------------------------------------------------
/res/layout-land/base_camera.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     android:layout_width="match_parent"
 4 |     android:layout_height="match_parent" >
 5 |     <SurfaceView
 6 |         android:id="@+id/surface_grabber_holder"
 7 |         android:layout_width="match_parent"
 8 |         android:layout_height="match_parent" />
 9 | 
10 |     <View
11 |         android:id="@+id/overlay_view"
12 |         android:layout_width="match_parent"
13 |         android:layout_height="match_parent" />
14 |     
15 | 
16 |          <LinearLayout
17 |         android:layout_width="match_parent"
18 |         android:layout_height="wrap_content"
19 |         android:layout_alignParentLeft="true"    
20 |         android:orientation="horizontal"		
21 | 		android:padding="6dp"	
22 |          >
23 | 
24 |         <ImageView 	
25 |             android:contentDescription="secure indicator"	    
26 | 		    android:layout_width="48dp"
27 |             android:layout_height="48dp"	    
28 | 		    android:background="@drawable/ic_action_secure"
29 | 		     style="?android:attr/buttonBarButtonStyle"/>
30 |  
31 |     <TextView
32 |         android:id="@+id/surface_grabber_progress"
33 |         android:layout_width="wrap_content"
34 |         android:layout_height="wrap_content"
35 |         android:textSize="36dp"
36 |         android:textColor="#B3ff0000"
37 |         />
38 | 
39 |     </LinearLayout>
40 |     
41 |     
42 |     <RelativeLayout
43 |         android:layout_width="wrap_content"
44 |         android:layout_height="match_parent"
45 |         android:orientation="vertical"        
46 |         android:layout_alignParentRight="true"
47 |         android:padding="6dp"
48 |        >
49 | 
50 |         <Button
51 |             android:id="@+id/surface_grabber_button"
52 |             android:layout_width="48dp"
53 |             android:layout_height="48dp"
54 |         	android:layout_alignParentTop="true"
55 |             android:background="@drawable/ic_action_video"
56 |             style="?android:attr/buttonBarButtonStyle"                       
57 |              />
58 |          
59 |         	<Button 
60 | 		    android:id="@+id/selfie_button"
61 | 		    android:layout_width="48dp"
62 |             android:layout_height="48dp"	    
63 | 		    android:background="@drawable/ic_action_switch_camera"
64 | 		    android:layout_alignParentBottom="true"
65 | 		    style="?android:attr/buttonBarButtonStyle"
66 | 		    
67 | 		    />
68 | 
69 |     </RelativeLayout>
70 | 
71 | </RelativeLayout>


--------------------------------------------------------------------------------
/res/layout/activity_gallery.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <GridView xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     android:id="@+id/gridview"
 4 |     android:layout_width="match_parent"
 5 |     android:layout_height="match_parent"
 6 |     android:columnWidth="90dp"
 7 |     android:numColumns="auto_fit"    
 8 |     android:verticalSpacing="9dp"
 9 |     android:horizontalSpacing="9dp"
10 |     android:stretchMode="columnWidth"
11 |     android:gravity="center"
12 |     android:layout_margin="3dp"
13 | />


--------------------------------------------------------------------------------
/res/layout/activity_lock_screen.xml:
--------------------------------------------------------------------------------
  1 | <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  2 |     android:id="@+id/llRoot"
  3 |     android:layout_width="match_parent"
  4 |     android:layout_height="match_parent"
  5 |     android:gravity="center"
  6 |     android:padding="20dp"
  7 |     android:orientation="vertical"
  8 |     android:background="#aaaaaa"
  9 |      >
 10 | 
 11 |     
 12 |     <ImageView        
 13 |         android:src="@drawable/splash"
 14 |         android:layout_width="128dp"
 15 |         android:layout_height="128dp"
 16 |         />
 17 |     
 18 |     
 19 |         <FrameLayout
 20 |             android:layout_width="match_parent"
 21 |             android:layout_height="wrap_content" >
 22 | 
 23 |             <LinearLayout
 24 |                 android:id="@+id/llCreatePassphrase"
 25 |                 android:layout_width="match_parent"
 26 |                 android:layout_height="wrap_content"
 27 |                 android:orientation="vertical" >
 28 |                 
 29 |                 <ViewFlipper
 30 |                     android:id="@+id/viewFlipper1"
 31 |                     android:layout_width="match_parent"
 32 |                     android:layout_height="wrap_content" >
 33 | 
 34 |                     <LinearLayout
 35 |                         android:id="@+id/flipView1"
 36 |                         android:layout_width="match_parent"
 37 |                         android:layout_height="wrap_content"
 38 |                         android:layout_margin="5dp"
 39 |                       
 40 |                          >
 41 | 
 42 |                         <EditText
 43 |                             android:id="@+id/editNewPassphrase"
 44 |                             android:layout_width="0dp"
 45 |                             android:layout_height="wrap_content"
 46 |                             android:layout_weight="1"
 47 |                             android:hint="@string/lock_screen_passphrase_not_set_enter"
 48 |                             android:inputType="textPassword"
 49 |                             android:background="#cccccc"
 50 |                             android:gravity="center" 
 51 | 						    android:layout_gravity="center"
 52 | 						    android:padding="6dp"
 53 |                              />
 54 |                     </LinearLayout>
 55 | 
 56 |                     <LinearLayout
 57 |                         android:id="@+id/flipView2"
 58 |                         android:layout_width="match_parent"
 59 |                         android:layout_height="wrap_content"
 60 |                         android:layout_margin="5dp" >
 61 | 
 62 |                         <EditText
 63 |                             android:id="@+id/editConfirmNewPassphrase"
 64 |                             android:layout_width="0dp"
 65 |                             android:layout_height="wrap_content"
 66 |                             android:layout_weight="1"
 67 |                             android:ems="10"
 68 |                             android:hint="@string/lock_screen_passphrase_not_set_confirm"
 69 |                             android:inputType="textPassword"
 70 |                             android:background="#cccccc"                            
 71 | 						    android:gravity="center" 
 72 | 						    android:layout_gravity="center"
 73 | 						    android:padding="6dp"
 74 | 						    
 75 |                              />
 76 |                     </LinearLayout>
 77 |                 </ViewFlipper>
 78 | 
 79 |                 <!-- 
 80 |                 <Button
 81 |                     
 82 |                     android:id="@+id/btnCreate"
 83 |                     android:layout_width="match_parent"
 84 |                     android:layout_height="wrap_content"
 85 |                     android:layout_margin="15dp"
 86 |                     android:text="@string/lock_screen_create_passphrase" />
 87 |  -->
 88 |             </LinearLayout>
 89 | 
 90 |             <LinearLayout
 91 |                 android:id="@+id/llEnterPassphrase"
 92 |                 android:layout_width="match_parent"
 93 |                 android:layout_height="wrap_content"
 94 |                 android:orientation="vertical"
 95 |                 android:visibility="invisible" >
 96 | 
 97 |                 <LinearLayout
 98 |                     android:id="@+id/llManualAdd"
 99 |                     android:layout_width="match_parent"
100 |                     android:layout_height="wrap_content"
101 |                     android:layout_margin="5dp" >
102 | 
103 |                     <EditText
104 |                         android:id="@+id/editEnterPassphrase"
105 |                         android:layout_width="match_parent"
106 |                         android:layout_height="wrap_content"
107 |                         android:ems="10"
108 |                         android:hint="@string/lock_screen_passphrase_hint"
109 |                         android:imeOptions="actionGo"
110 |                         android:inputType="textPassword"
111 |                         android:background="#cccccc"                            
112 | 						    android:gravity="center" 
113 | 						    android:layout_gravity="center"
114 | 						android:padding="6dp"
115 |                          >
116 | 
117 |                         <requestFocus />
118 |                     </EditText>
119 |                 </LinearLayout>
120 | <!-- 
121 |                 <Button
122 |                     android:id="@+id/btnOpen"
123 |                     android:layout_width="match_parent"
124 |                     android:layout_height="wrap_content"
125 |                     android:layout_margin="15dp"
126 |                     android:text="@string/lock_screen_open" />
127 |  -->
128 |             </LinearLayout>
129 |         </FrameLayout>
130 | 
131 | </LinearLayout>


--------------------------------------------------------------------------------
/res/layout/base_camera.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     android:layout_width="match_parent"
 4 |     android:layout_height="match_parent"
 5 |     android:orientation="vertical" >
 6 |     <SurfaceView
 7 |         android:id="@+id/surface_grabber_holder"
 8 |         android:layout_width="match_parent"
 9 |         android:layout_height="match_parent" />
10 |     
11 |     <View
12 |         android:id="@+id/overlay_view"
13 |         android:layout_width="match_parent"
14 |         android:layout_height="match_parent" />
15 | 
16 | 
17 |      <RelativeLayout
18 |         android:layout_width="match_parent"
19 |         android:layout_height="wrap_content"
20 |         android:layout_alignParentTop="true"
21 |                 android:layout_alignParentRight="true"        
22 |         android:orientation="horizontal"		
23 | 		android:padding="6dp"	
24 |          >
25 | 
26 |         <ImageView 	
27 |             android:contentDescription="secure indicator"	    
28 | 		    android:layout_width="48dp"
29 |             android:layout_height="48dp"	    
30 | 		    android:background="@drawable/ic_action_secure"
31 | 		     style="?android:attr/buttonBarButtonStyle"/>
32 |      <TextView
33 |         android:id="@+id/surface_grabber_progress"
34 |         android:layout_width="wrap_content"
35 |         android:layout_height="wrap_content"
36 |         android:layout_alignParentRight="true"
37 |         android:layout_alignParentTop="true"
38 |         android:layout_margin="10dip"
39 |         android:layout_marginRight="35dp"
40 |         android:layout_marginTop="118dp"        
41 |         android:padding="10dip"
42 |         android:textSize="30sp"
43 |         android:textColor="#B3ff0000"
44 |         />
45 |         
46 | 
47 |     </RelativeLayout>
48 |     
49 |     <RelativeLayout
50 |         android:layout_width="match_parent"
51 |         android:layout_height="wrap_content"
52 |         android:layout_alignParentBottom="true"
53 |                 android:layout_alignParentRight="true"        
54 |         android:orientation="horizontal"		
55 | 		android:padding="6dp"	
56 |          >
57 | 
58 |         <Button 
59 | 		    android:id="@+id/selfie_button"
60 | 		    android:layout_width="48dp"
61 |             android:layout_height="48dp"	    
62 | 		    android:background="@drawable/ic_action_switch_video"
63 | 		     style="?android:attr/buttonBarButtonStyle"/>
64 |  
65 | 
66 |         <Button
67 |             android:id="@+id/surface_grabber_button"
68 |             android:layout_width="48dp"
69 |             android:layout_height="48dp"
70 |             android:layout_gravity="center"
71 |             android:background="@drawable/ic_action_video"
72 |            style="?android:attr/buttonBarButtonStyle"
73 |                            android:layout_alignParentRight="true"        
74 |            
75 |            />
76 |     </RelativeLayout>
77 | 
78 | </RelativeLayout>


--------------------------------------------------------------------------------
/res/layout/gallery_gridsq.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     android:layout_width="wrap_content"
 4 |     android:layout_height="wrap_content" 
 5 |     android:orientation="horizontal"
 6 |     android:padding="3dp"
 7 |     android:background="#ffffff"
 8 |     android:layout_gravity="center"
 9 |     android:gravity="center"
10 |     >
11 | 
12 |     <ImageView
13 |         android:id="@+id/icon"
14 |         android:layout_width="128dp"
15 |         android:layout_height="128dp"
16 |         android:scaleType="centerCrop"
17 |         />
18 | 
19 | />
20 | 
21 | </LinearLayout>


--------------------------------------------------------------------------------
/res/layout/pzsimageview.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     android:layout_width="match_parent"
 4 |     android:layout_height="match_parent"
 5 |     android:orientation="vertical" >
 6 | 
 7 |     <info.guardianproject.iocipher.camera.viewer.PZSImageView
 8 |         android:id="@+id/imageview"
 9 |         android:layout_width="match_parent"
10 |         android:layout_height="match_parent" />
11 | 
12 | </LinearLayout>


--------------------------------------------------------------------------------
/res/layout/videoview.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     android:layout_width="match_parent"
 4 |     android:layout_height="match_parent"
 5 |     android:orientation="vertical" >
 6 |     <SurfaceView
 7 |         android:id="@+id/surface_video"
 8 |         android:layout_width="match_parent"
 9 |         android:layout_height="match_parent" />
10 | 
11 | 
12 | </RelativeLayout>


--------------------------------------------------------------------------------
/res/menu/main.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!--
 3 | /*
 4 |  * Copyright (C) 2008 Esmertec AG.
 5 |  * Copyright (C) 2008 The Android Open Source Project
 6 |  *
 7 |  * Licensed under the Apache License, Version 2.0 (the "License");
 8 |  * you may not use this file except in compliance with the License.
 9 |  * You may obtain a copy of the License at
10 |  *
11 |  *      http://www.apache.org/licenses/LICENSE-2.0
12 |  *
13 |  * Unless required by applicable law or agreed to in writing, software
14 |  * distributed under the License is distributed on an "AS IS" BASIS,
15 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 |  * See the License for the specific language governing permissions and
17 |  * limitations under the License.
18 |  */
19 | -->
20 | <menu 
21 |     xmlns:android="http://schemas.android.com/apk/res/android">
22 | 
23 |  <item
24 |       android:title="Photo"
25 |         android:id="@+id/menu_camera"
26 |          android:showAsAction="always"
27 |          android:icon="@drawable/ic_action_camera"
28 |          >
29 |          
30 |      </item>
31 | 
32 |  <item
33 |         android:title="Video"
34 |         android:id="@+id/menu_video"
35 |          android:showAsAction="always"
36 |          android:icon="@drawable/ic_action_video"
37 |          
38 |          >
39 |      
40 |  </item>
41 |  
42 |  <item android:title="Lock"
43 |      android:id="@+id/menu_lock"
44 |      android:showAsAction="always"
45 |               android:icon="@drawable/ic_action_secure"
46 |      
47 |      />
48 | </menu>


--------------------------------------------------------------------------------
/res/values/colors.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <resources>
3 |     <color name="flash">#AAFFFFFF</color>    
4 | </resources>
5 | 


--------------------------------------------------------------------------------
/res/values/strings.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <resources>
 3 | 
 4 |     <string name="app_name">CipherCam</string>
 5 | 
 6 |     
 7 |     <string name="lock_screen_open">Open</string>
 8 |     <string name="title_activity_lock_screen">Locked</string>
 9 |     <string name="lock_screen_create_passphrase">Create passphrase</string>
10 | 	<string name="lock_screen_passphrase_hint">Enter passphrase</string>
11 | 	<string name="lock_screen_passphrase_not_set_enter">Enter new passphrase</string>
12 | 	<string name="lock_screen_passphrase_not_set_confirm">Confirm new passphrase</string>
13 | 	<string name="lock_screen_passphrases_not_matching">Passphrases did not match, please try again</string>
14 | 	
15 | 	<string name="pass_err_length">Your passphrase is too short</string>
16 | 	
17 | 	<string name="install_orbot_">Install Orbot?</string>
18 | 	
19 | 	<string name="market_orbot">market://search?q=pname:org.torproject.android</string>
20 | 	
21 | 	<string name="you_must_have_orbot">You must have Orbot installed and activated to proxy traffic through it. Would you like to install it from Google Play?</string>
22 | 	
23 | 	<string name="yes">Yes</string>
24 | 	
25 | 	<string name="no">No</string>
26 | 	
27 | 	<string name="always">Always</string>
28 | 	
29 | 	<string name="start_orbot_">Start Orbot?</string>
30 | 	
31 | 	<string name="orbot_doesn_t_appear_to_be_running_would_you_like_to_start_it_up_and_connect_to_tor_">Orbot doesn\'t appear to be running. Would you like to start it up and connect to Tor?</string>
32 | 	
33 | </resources>


--------------------------------------------------------------------------------
/src/info/guardianproject/iocipher/camera/AudioRecorderActivity.java:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * 
  3 |  * This file contains code from the IOCipher Camera Library "CipherCam".
  4 |  *
  5 |  * For more information about IOCipher, see https://guardianproject.info/code/iocipher
  6 |  * and this sample library: https://github.com/n8fr8/IOCipherCameraExample
  7 |  *
  8 |  * IOCipher Camera Sample is distributed under this license (aka the 3-clause BSD license)
  9 |  *
 10 |  * @author n8fr8
 11 |  * 
 12 |  */
 13 | 
 14 | package info.guardianproject.iocipher.camera;
 15 | 
 16 | import info.guardianproject.iocipher.File;
 17 | import info.guardianproject.iocipher.camera.encoders.AACHelper;
 18 | 
 19 | import java.io.BufferedOutputStream;
 20 | import java.io.IOException;
 21 | import java.io.OutputStream;
 22 | 
 23 | import android.app.Activity;
 24 | import android.media.AudioFormat;
 25 | import android.media.AudioRecord;
 26 | import android.media.MediaRecorder;
 27 | import android.os.Bundle;
 28 | import android.os.Handler;
 29 | import android.os.Message;
 30 | import android.provider.MediaStore;
 31 | import android.util.Log;
 32 | import android.view.View;
 33 | import android.view.View.OnClickListener;
 34 | import android.widget.Toast;
 35 | 
 36 | public class AudioRecorderActivity extends Activity implements OnClickListener {
 37 | 	
 38 | 	private final static String LOG = "AudioRecorder";
 39 | 	
 40 | 	private String mFileBasePath = null;
 41 | 	private boolean mIsRecording = false;
 42 | 
 43 | 	private AACHelper aac;
 44 | 	private boolean useAAC = false;
 45 | 	private byte[] audioData;
 46 | 	private AudioRecord audioRecord;
 47 | 	
 48 | 	private OutputStream outputStreamAudio;
 49 | 	private info.guardianproject.iocipher.File fileAudio;
 50 | 	
 51 | 	private boolean isRequest = false;
 52 | 	
 53 | 	@Override
 54 | 	public void onCreate(Bundle savedInstanceState) {
 55 | 		super.onCreate(savedInstanceState);
 56 | 		mFileBasePath = getIntent().getStringExtra("basepath");
 57 | 		
 58 | 		isRequest = getIntent().getAction() != null && getIntent().getAction().equals(MediaStore.ACTION_VIDEO_CAPTURE);
 59 | 
 60 | 	}
 61 | 	
 62 | 	final Handler handler = new Handler(); 
 63 | 	Runnable mLongPressed = new Runnable() { 
 64 | 	    public void run() { 
 65 | 	        Log.i("", "Long press!");
 66 | 	        
 67 | 	        startRecording();
 68 | 	        
 69 | 	    }   
 70 | 	};
 71 | 
 72 | 	@Override
 73 | 	public void onClick(View view) {
 74 | 			
 75 | 		if (!mIsRecording)
 76 | 		{
 77 | 			
 78 | 			startRecording();
 79 | 			
 80 | 			
 81 | 		}
 82 | 		else
 83 | 		{
 84 | 			stopRecording ();
 85 | 		}
 86 | 		
 87 | 	}
 88 | 	
 89 | 	private void startRecording ()
 90 | 	{
 91 | 		String fileName = "audio" + new java.util.Date().getTime();
 92 | 		info.guardianproject.iocipher.File fileOut = new info.guardianproject.iocipher.File(mFileBasePath,fileName);
 93 | 		
 94 | 		try {
 95 | 			mIsRecording = true;
 96 | 			
 97 | 			if (useAAC)
 98 | 				initAudio(fileOut.getAbsolutePath()+".aac");
 99 | 			else
100 | 				initAudio(fileOut.getAbsolutePath()+".pcm");
101 | 			
102 | 			
103 | 			startAudioRecording();
104 | 			
105 | 
106 | 		} catch (Exception e) {
107 | 			Log.d("Video","error starting video",e);
108 | 			Toast.makeText(this, "Error init'ing video: " + e.getLocalizedMessage(), Toast.LENGTH_LONG).show();
109 | 			finish();
110 | 		}
111 | 	}
112 | 	
113 | 	private void stopRecording ()
114 | 	{
115 | 		h.sendEmptyMessageDelayed(1, 2000);
116 | 	}
117 | 	
118 | 	
119 | 	Handler h = new Handler ()
120 | 	{
121 | 
122 | 		@Override
123 | 		public void handleMessage(Message msg) {
124 | 			// TODO Auto-generated method stub
125 | 			super.handleMessage(msg);
126 | 			
127 | 			if (msg.what == 0)
128 | 			{
129 | 				
130 | 			}
131 | 			else if (msg.what == 1)
132 | 			{
133 | 				mIsRecording = false; //stop recording
134 | 				
135 | 				if (aac != null)
136 | 					aac.stopRecording();
137 | 			}
138 | 		}
139 | 		
140 | 	};
141 | 	
142 | 	 private void initAudio(final String audioPath) throws Exception {
143 | 
144 | 			fileAudio  = new File(audioPath); 
145 | 			
146 | 			   outputStreamAudio = new BufferedOutputStream(new info.guardianproject.iocipher.FileOutputStream(fileAudio),8192*8);
147 | 				
148 | 			   if (useAAC)
149 | 			   {
150 | 				   aac = new AACHelper();
151 | 				   aac.setEncoder(MediaConstants.sAudioSampleRate, MediaConstants.sAudioChannels, MediaConstants.sAudioBitRate);
152 | 			   }
153 | 			   else
154 | 			   {
155 | 			   
156 | 				   int minBufferSize = AudioRecord.getMinBufferSize(MediaConstants.sAudioSampleRate, 
157 | 					MediaConstants.sChannelConfigIn, 
158 | 				     AudioFormat.ENCODING_PCM_16BIT)*8;
159 | 				   
160 | 				   audioData = new byte[minBufferSize];
161 | 	
162 | 				   int audioSource = MediaRecorder.AudioSource.CAMCORDER;
163 | 				   // audioSource = MediaRecorder.AudioSource.MIC;
164 | 				   
165 | 				   audioRecord = new AudioRecord(audioSource,
166 | 						   MediaConstants.sAudioSampleRate,
167 | 						   MediaConstants.sChannelConfigIn,
168 | 				     AudioFormat.ENCODING_PCM_16BIT,
169 | 				     minBufferSize);
170 | 			   }
171 | 	 }
172 | 	 
173 | 	 private void startAudioRecording ()
174 | 	 {
175 | 			  
176 | 		 
177 | 		 Thread thread = new Thread ()
178 | 		 {
179 | 			 
180 | 			 public void run ()
181 | 			 {
182 | 			 
183 | 				 if (useAAC)
184 | 				 {
185 | 					 try {
186 | 						aac.startRecording(outputStreamAudio);
187 | 					} catch (IOException e) {
188 | 						// TODO Auto-generated catch block
189 | 						e.printStackTrace();
190 | 					}
191 | 				 }
192 | 				 else
193 | 				 {
194 | 				   audioRecord.startRecording();
195 | 				   
196 | 				   while(mIsRecording){
197 | 				    int audioDataBytes = audioRecord.read(audioData, 0, audioData.length);
198 | 				    if (AudioRecord.ERROR_INVALID_OPERATION != audioDataBytes
199 | 		                    && outputStreamAudio != null) {
200 | 		                try {
201 | 		                	outputStreamAudio.write(audioData,0,audioDataBytes);
202 | 		                	
203 | 		                	//muxer.addAudio(ByteBuffer.wrap(audioData, 0, audioData.length));
204 | 		                } catch (IOException e) {
205 | 		                    e.printStackTrace();
206 | 		                }
207 | 		            }
208 | 				   }
209 | 				   
210 | 				   audioRecord.stop();
211 | 				   audioRecord.release();
212 | 				   audioRecord = null;
213 | 				   
214 | 				   try {
215 | 					   outputStreamAudio.flush();
216 | 					outputStreamAudio.close();
217 | 					} catch (IOException e) {
218 | 						// TODO Auto-generated catch block
219 | 						e.printStackTrace();
220 | 					}
221 | 				 }
222 | 				 
223 | 				 
224 | 			 }
225 | 		 };
226 | 		 
227 | 		 thread.start();
228 | 
229 | 	 }
230 | 	 
231 | 	 
232 | 	
233 | }
234 | 


--------------------------------------------------------------------------------
/src/info/guardianproject/iocipher/camera/CameraBaseActivity.java:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * 
  3 |  * This file contains code from the IOCipher Camera Library "CipherCam".
  4 |  *
  5 |  * For more information about IOCipher, see https://guardianproject.info/code/iocipher
  6 |  * and this sample library: https://github.com/n8fr8/IOCipherCameraExample
  7 |  *
  8 |  * IOCipher Camera Sample is distributed under this license (aka the 3-clause BSD license)
  9 |  *
 10 |  * @author n8fr8
 11 |  * 
 12 |  */
 13 | 
 14 | package info.guardianproject.iocipher.camera;
 15 | 
 16 | import java.io.IOException;
 17 | import java.util.List;
 18 | 
 19 | import android.annotation.SuppressLint;
 20 | import android.app.Activity;
 21 | import android.content.pm.PackageManager;
 22 | import android.content.res.Configuration;
 23 | import android.graphics.Bitmap;
 24 | import android.graphics.Canvas;
 25 | import android.graphics.ImageFormat;
 26 | import android.graphics.Picture;
 27 | import android.graphics.Rect;
 28 | import android.hardware.Camera;
 29 | import android.hardware.Camera.CameraInfo;
 30 | import android.hardware.Camera.Parameters;
 31 | import android.hardware.Camera.PictureCallback;
 32 | import android.hardware.Camera.PreviewCallback;
 33 | import android.hardware.Camera.Size;
 34 | import android.os.Build;
 35 | import android.os.Bundle;
 36 | import android.util.Log;
 37 | import android.view.MotionEvent;
 38 | import android.view.Surface;
 39 | import android.view.SurfaceHolder;
 40 | import android.view.SurfaceView;
 41 | import android.view.View;
 42 | import android.view.View.OnClickListener;
 43 | import android.view.View.OnTouchListener;
 44 | import android.widget.Button;
 45 | import android.widget.ImageView;
 46 | import android.widget.TextView;
 47 | 
 48 | import com.larvalabs.svgandroid.SVG;
 49 | import com.larvalabs.svgandroid.SVGParser;
 50 | 
 51 | public abstract class CameraBaseActivity extends Activity implements OnClickListener, OnTouchListener, SurfaceHolder.Callback, PictureCallback, PreviewCallback {
 52 | 	
 53 | 	Button button;
 54 | 	TextView progress;
 55 | 	
 56 | 	Button buttonSelfie;
 57 | 	boolean mIsSelfie = false;
 58 | 	
 59 | 	SurfaceView view;
 60 | 	SurfaceHolder holder;
 61 | 	Camera camera;
 62 | 	CameraInfo cameraInfo;
 63 | 	
 64 | 	View overlayView;
 65 | 	
 66 | 	protected boolean mPreviewing;
 67 | 
 68 | 	private final static String LOG = "CipherCam";
 69 | 
 70 | 	protected int mRotation = 0;
 71 | 
 72 | 	private int mPreviewWidth = -1;
 73 | 	private int mPreviewHeight = -1;
 74 | 	
 75 | 	@SuppressWarnings("deprecation")
 76 | 	@Override
 77 | 	public void onCreate(Bundle savedInstanceState) {
 78 | 		super.onCreate(savedInstanceState);
 79 | 
 80 | 		View decorView = getWindow().getDecorView();
 81 | 		int uiOptions = View.SYSTEM_UI_FLAG_LOW_PROFILE;
 82 | 		decorView.setSystemUiVisibility(uiOptions);
 83 | 				
 84 | 		setContentView(getLayout());
 85 | 		
 86 | 		mIsSelfie = getIntent().getBooleanExtra("selfie", false);
 87 | 
 88 | 		button = (Button) findViewById(R.id.surface_grabber_button);
 89 | 		button.setOnClickListener(this);
 90 | 		
 91 | 		buttonSelfie = (Button)findViewById(R.id.selfie_button);
 92 | 		buttonSelfie.setOnClickListener(new OnClickListener()
 93 | 		{
 94 | 
 95 | 			@Override
 96 | 			public void onClick(View v) {
 97 | 				toggleCamera();
 98 | 				
 99 | 			}
100 | 			
101 | 		});
102 | 		
103 | 		progress = (TextView) findViewById(R.id.surface_grabber_progress);
104 | 		view = (SurfaceView) findViewById(R.id.surface_grabber_holder);
105 | 		overlayView = findViewById(R.id.overlay_view);
106 | 	        
107 | 		  
108 | 		holder = view.getHolder();
109 | 		holder.addCallback(this);
110 | 		holder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
111 | 		
112 | 		view.setOnClickListener(this);
113 | 				
114 | 		view.setOnTouchListener(this);
115 | 		
116 | 	}
117 | 	
118 | 	/*
119 | 	private void setOverlayImage (String path)
120 |     {
121 |         try 
122 |         {
123 |         	
124 |         	Bitmap bitmap = Bitmap.createBitmap(overlayView.getWidth(),overlayView.getHeight(), Bitmap.Config.ARGB_8888);
125 |             Canvas canvas = new Canvas(bitmap);
126 |             
127 |             SVG svg = SVGParser.getSVGFromAsset(getAssets(), path);
128 | 
129 |             Rect rBounds = new Rect(0,0,overlayView.getWidth(),overlayView.getHeight());
130 |             Picture p = svg.getPicture();                       
131 |             canvas.drawPicture(p, rBounds);            
132 |             
133 |             overlayView.setImageBitmap( bitmap);
134 |         }
135 |         catch(IOException ex) 
136 |         {
137 |         	Log.e("BaseCamera","error rendering overlay",ex);
138 |             return;
139 |         }
140 |         
141 |     }*/
142 |     
143 | 	
144 | 	protected int getLayout()
145 | 	{
146 | 		return R.layout.base_camera;
147 | 	}
148 | 	
149 | 
150 | 	protected int getCameraDirection() {
151 | 		if (mIsSelfie)
152 | 			return CameraInfo.CAMERA_FACING_FRONT;
153 | 		else
154 | 			return CameraInfo.CAMERA_FACING_BACK;
155 | 	}
156 | 
157 | 	
158 | 	/**
159 |      * Whether or not we can default to "other" direction if our preferred facing camera can't be opened
160 |      * @return true to try camera facing other way, false otherwise
161 |      */
162 |     protected boolean canUseOtherDirection()
163 |     {
164 |             return false;
165 |     }
166 | 
167 | 	
168 | 	@Override
169 | 	public void onResume() {
170 | 		super.onResume();
171 | 		
172 | 		initCamera();
173 | 	}
174 | 	
175 | 	protected void initCamera()
176 | 	{
177 | 
178 | 		if (!tryCreateCamera(getCameraDirection()))
179 |         {
180 |                 if (!canUseOtherDirection() || !tryCreateCamera(getOtherDirection(getCameraDirection())))
181 |                 {
182 |                         finish();
183 |                         return;
184 |                 }
185 |         }
186 | 
187 | 		if(camera == null)
188 | 			finish();
189 | 		
190 | 	}
191 | 
192 | 	private int getOtherDirection(int facing)
193 | 	{
194 | 		return (facing == CameraInfo.CAMERA_FACING_BACK) ? CameraInfo.CAMERA_FACING_FRONT : CameraInfo.CAMERA_FACING_BACK;
195 | 	}
196 | 	
197 | 	@SuppressLint("NewApi")
198 | 	private boolean tryCreateCamera(int facing)
199 | 	{
200 | 	     Camera.CameraInfo info = new Camera.CameraInfo();
201 | 	     for (int nCam = 0; nCam < Camera.getNumberOfCameras(); nCam++)
202 | 	     {
203 | 		     Camera.getCameraInfo(nCam, info);
204 | 		     if (info.facing == facing)
205 | 		     {
206 | 		    	 camera = Camera.open(nCam);
207 | 		    	 cameraInfo = info;
208 | 
209 | 		    	 Camera.Parameters params = camera.getParameters();
210 | 				 params.setPictureFormat(ImageFormat.JPEG);
211 | 				 
212 | 				 mRotation = setCameraDisplayOrientation(this,nCam,camera);
213 | 				 
214 | 				 List<Camera.Size> supportedPreviewSizes =  camera.getParameters().getSupportedPreviewSizes();
215 | 				 List<Camera.Size> supportedPictureSize = camera.getParameters().getSupportedPictureSizes();
216 | 				 
217 | 				 int previewQuality = 5;
218 | 				 
219 | 				 if (mPreviewWidth == -1)
220 | 					 mPreviewWidth = supportedPreviewSizes.get(previewQuality).width;
221 | 				 
222 | 				 if (mPreviewHeight == -1)
223 | 					 mPreviewHeight = supportedPreviewSizes.get(previewQuality).height;
224 | 				 
225 | 				 params.setPreviewSize(mPreviewWidth, mPreviewHeight);
226 | 				 
227 | 				 params.setPictureSize(supportedPictureSize.get(1).width, supportedPictureSize.get(1).height);
228 | 				 
229 | 				 if (this.getCameraDirection() == CameraInfo.CAMERA_FACING_BACK)
230 | 				 {
231 | 					 if (getPackageManager().hasSystemFeature(
232 | 					            PackageManager.FEATURE_CAMERA_AUTOFOCUS))
233 | 					        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
234 | 					            params.setFocusMode(Parameters.FOCUS_MODE_AUTO);
235 | 					        } 
236 | 					 
237 | 					 
238 | 					 if (mRotation > 0)
239 | 						 params.setRotation(mRotation);
240 | 
241 | 					 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH_MR1) {
242 | 						 if (params.isVideoStabilizationSupported())
243 | 							 params.setVideoStabilization(true);
244 | 						 
245 | 					 }
246 | 					 
247 | 				 }
248 | 				 else
249 | 				 {
250 | 					 if (mRotation > 0)
251 | 						 params.setRotation(360-mRotation);
252 | 				 }
253 | 									
254 | 				 camera.setParameters(params);
255 | 				
256 | 					/*
257 | 	                for (int i = 0; i < BUFFER_COUNT; i++) {
258 | 	                    byte[] buffer = new byte[mPreviewWidth * mPreviewHeight *
259 | 	                        ImageFormat.getBitsPerPixel(ImageFormat.NV21) / 8];
260 | 	                    camera.addCallbackBuffer(buffer);
261 | 	                    
262 | 	                }
263 | 			        
264 | //					camera.setPreviewCallback(this);
265 | 			        camera.setPreviewCallbackWithBuffer(this);
266 | 			        */
267 | 					camera.setPreviewCallback(this);
268 | 			        
269 | 					if (holder != null)
270 | 						try {
271 | 							camera.setPreviewDisplay(holder);
272 | 							camera.startPreview();
273 | 						} catch (IOException e) {
274 | 							// TODO Auto-generated catch block
275 | 							e.printStackTrace();
276 | 						}
277 | 					//start video
278 | 			        
279 | 		    	 return true;
280 | 		     }
281 | 	     }
282 | 	     return false;
283 | 	}
284 | 	
285 | 	
286 | 	@Override
287 | 	public void onPause() {
288 | 		releaseCamera();
289 | 				
290 | 		super.onPause();
291 | 	}
292 | 	
293 | 	protected void releaseCamera ()
294 | 	{
295 | 		try
296 | 	    {    
297 | 	        // release the camera immediately on pause event   
298 | 			camera.stopPreview(); 
299 | 			camera.setPreviewCallback(null);
300 | 			camera.release();
301 | 			camera = null;
302 | 
303 | 	    }
304 | 	    catch(Exception e)
305 | 	    {
306 | 	        e.printStackTrace();
307 | 	    }
308 | 
309 | 	}
310 | 
311 | 	@Override
312 | 	public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
313 | 		
314 | 		if (camera != null)
315 | 		{
316 | 			camera.startPreview();
317 | 			mPreviewing = true;
318 | 		}
319 | 	}
320 | 
321 | 	protected Size choosePictureSize(List<Size> localSizes)
322 | 	{
323 | 		Size size = null;
324 | 		
325 | 		for(Size sz : localSizes) {
326 | 			if(sz.width > 640 && sz.width <= 1024)
327 | 				size = sz;
328 | 			
329 | 			if(size != null)
330 | 				break;
331 | 		}
332 | 		
333 | 		if(size == null)
334 | 			size = localSizes.get(localSizes.size() - 1);
335 | 		return size;
336 | 	}
337 | 	
338 | 	@Override
339 | 	public void surfaceCreated(SurfaceHolder holder) {
340 | 		try {
341 | 			
342 | 			this.holder = holder;
343 | 			
344 | 			if (camera != null)
345 | 				camera.setPreviewDisplay(holder);
346 | 			
347 | 		} catch(IOException e) {
348 | 			Log.e(LOG, e.toString());
349 | 		}
350 | 	}
351 | 
352 | 	@Override
353 | 	public void surfaceDestroyed(SurfaceHolder holder) {}
354 | 
355 | 	@Override
356 | 	public void onClick(View view) {
357 | 		if(mPreviewing) {
358 | 			mPreviewing = false;
359 | 			camera.takePicture(null, null, this);
360 | 		}
361 | 	}
362 | 	
363 | 
364 | 	@Override
365 | 	public boolean onTouch(View v, MotionEvent event) {
366 | 		
367 | 		return false;
368 | 	}
369 | 
370 | 	
371 | 
372 | 	private void toggleCamera ()
373 | 	{
374 | 		mIsSelfie = !mIsSelfie;
375 | 		releaseCamera();
376 | 		initCamera();
377 | 	}
378 | 	
379 | 	@Override
380 | 	public void onPictureTaken(byte[] data, Camera camera) {
381 | 		//do nothing by default
382 | 	}
383 | 	
384 | 
385 | 	@Override
386 | 	public void onPreviewFrame(byte[] data, Camera camera) {
387 | 
388 | 		//do nothing by default
389 | 	}
390 | 
391 | 
392 | 	protected void resumePreview()
393 | 	{
394 | 		if (!mPreviewing)
395 | 		{
396 | 			camera.startPreview();
397 | 			mPreviewing = true;
398 | 		}
399 | 	}
400 | 	
401 | 	
402 | 	public static int setCameraDisplayOrientation(Activity activity,
403 | 	         int cameraId, android.hardware.Camera camera) {
404 | 	     android.hardware.Camera.CameraInfo info =
405 | 	             new android.hardware.Camera.CameraInfo();
406 | 	     android.hardware.Camera.getCameraInfo(cameraId, info);
407 | 	     int rotation = activity.getWindowManager().getDefaultDisplay()
408 | 	             .getRotation();
409 | 	     int degrees = 0;
410 | 	     switch (rotation) {
411 | 	         case Surface.ROTATION_0: degrees = 0; break;
412 | 	         case Surface.ROTATION_90: degrees = 90; break;
413 | 	         case Surface.ROTATION_180: degrees = 180; break;
414 | 	         case Surface.ROTATION_270: degrees = 270; break;
415 | 	     }
416 | 
417 | 	     int result;
418 | 	     if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
419 | 	         result = (info.orientation + degrees) % 360;
420 | 	         result = (360 - result) % 360;  // compensate the mirror
421 | 	     } else {  // back-facing
422 | 	         result = (info.orientation - degrees + 360) % 360;
423 | 	     }
424 | 	     camera.setDisplayOrientation(result);
425 | 	     
426 | 	     return result;
427 | 	 }
428 | 	
429 | 
430 | 	   @Override
431 | 	   public void onConfigurationChanged(Configuration newConfig) {
432 | 	           super.onConfigurationChanged(newConfig);
433 | 
434 | 	           releaseCamera ();
435 | 	           initCamera();
436 | 	   }
437 | 	
438 | 	
439 | }


--------------------------------------------------------------------------------
/src/info/guardianproject/iocipher/camera/GalleryActivity.java:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * 
  3 |  * This file contains code from the IOCipher Camera Library "CipherCam".
  4 |  *
  5 |  * For more information about IOCipher, see https://guardianproject.info/code/iocipher
  6 |  * and this sample library: https://github.com/n8fr8/IOCipherCameraExample
  7 |  *
  8 |  * IOCipher Camera Sample is distributed under this license (aka the 3-clause BSD license)
  9 |  *
 10 |  * @author n8fr8
 11 |  * 
 12 |  */
 13 | 
 14 | package info.guardianproject.iocipher.camera;
 15 | 
 16 | import info.guardianproject.cacheword.CacheWordHandler;
 17 | import info.guardianproject.cacheword.ICacheWordSubscriber;
 18 | import info.guardianproject.iocipher.File;
 19 | import info.guardianproject.iocipher.FileInputStream;
 20 | import info.guardianproject.iocipher.FileOutputStream;
 21 | import info.guardianproject.iocipher.camera.io.IOCipherContentProvider;
 22 | import info.guardianproject.iocipher.camera.viewer.ImageViewerActivity;
 23 | import info.guardianproject.iocipher.camera.viewer.MjpegViewerActivity;
 24 | 
 25 | import java.io.BufferedOutputStream;
 26 | import java.io.FileNotFoundException;
 27 | import java.io.IOException;
 28 | import java.io.InputStream;
 29 | import java.io.OutputStream;
 30 | import java.util.ArrayList;
 31 | import java.util.HashMap;
 32 | import java.util.List;
 33 | 
 34 | import android.app.Activity;
 35 | import android.app.AlertDialog;
 36 | import android.content.ActivityNotFoundException;
 37 | import android.content.ContentResolver;
 38 | import android.content.DialogInterface;
 39 | import android.content.Intent;
 40 | import android.content.res.Configuration;
 41 | import android.graphics.Bitmap;
 42 | import android.graphics.BitmapFactory;
 43 | import android.net.Uri;
 44 | import android.os.Bundle;
 45 | import android.os.Handler;
 46 | import android.provider.MediaStore;
 47 | import android.util.Log;
 48 | import android.view.LayoutInflater;
 49 | import android.view.Menu;
 50 | import android.view.MenuInflater;
 51 | import android.view.MenuItem;
 52 | import android.view.View;
 53 | import android.view.ViewGroup;
 54 | import android.view.WindowManager;
 55 | import android.webkit.MimeTypeMap;
 56 | import android.widget.AdapterView;
 57 | import android.widget.AdapterView.OnItemClickListener;
 58 | import android.widget.AdapterView.OnItemLongClickListener;
 59 | import android.widget.ArrayAdapter;
 60 | import android.widget.GridView;
 61 | import android.widget.ImageView;
 62 | import android.widget.Toast;
 63 | 
 64 | public class GalleryActivity extends Activity  implements ICacheWordSubscriber {
 65 | 	private final static String TAG = "FileBrowser";
 66 | 
 67 | 	private List<String> item = null;
 68 | 	private List<String> path = null;
 69 | 	private String[] items;
 70 | 	private java.io.File dbFile;
 71 | 	private String root = "/";
 72 | 	
 73 | 	private GridView gridview;
 74 | 	private HashMap<String,Bitmap> mBitCache = new HashMap<String,Bitmap>();
 75 | 	private HashMap<String,BitmapWorkerThread> mBitLoaders = new HashMap<String,BitmapWorkerThread>();
 76 | 	
 77 | 	private CacheWordHandler mCacheWord;
 78 | 	
 79 | 	private final static int REQUEST_TAKE_PICTURE = 1000;
 80 | 	private final static int REQUEST_TAKE_VIDEO = 1001;
 81 | 	
 82 | 	private final static String ACTION_SECURE_STILL_IMAGE_CAMERA = "info.guardianproject.action.SECURE_STILL_IMAGE_CAMERA";
 83 | 	private final static String ACTION_SECURE_SECURE_VIDEO_CAMERA = "info.guardianproject.action.SECURE_VIDEO_CAMERA";
 84 | 	
 85 | 	private Handler h = new Handler();//for UI event handling
 86 | 	
 87 | 	private boolean mUseBuiltInLockScreen = false;
 88 | 	private boolean isExternalLaunch = false;
 89 | 
 90 | 	/** Called when the activity is first created. */
 91 | 	@Override
 92 | 	public void onCreate(Bundle savedInstanceState) {
 93 | 		super.onCreate(savedInstanceState);
 94 | 
 95 | 		//prevent screenshots
 96 | 		getWindow().setFlags(WindowManager.LayoutParams.FLAG_SECURE,
 97 | 				WindowManager.LayoutParams.FLAG_SECURE);
 98 | 
 99 | 		setContentView(R.layout.activity_gallery);
100 | 		
101 | 		gridview = (GridView) findViewById(R.id.gridview);
102 | 
103 |         mCacheWord = new CacheWordHandler(this, this);
104 |         mCacheWord.connectToService(); 
105 |         
106 | 		Intent intent = getIntent();
107 | 		String action = intent.getAction();
108 | 		String type = intent.getType();
109 | 		if (Intent.ACTION_SEND.equals(action) && type != null) {
110 | 			if (intent.hasExtra(Intent.EXTRA_STREAM)) {
111 | 				Log.i(TAG, "save extra stream URI");
112 | 				handleSendUri((Uri) intent.getExtras().get(Intent.EXTRA_STREAM));
113 | 			} else {
114 | 				Log.i(TAG, "save data");
115 | 				handleSendUri(intent.getData());
116 | 			}
117 | 		}
118 | 		else if (MediaStore.ACTION_IMAGE_CAPTURE.equals(action)
119 | 				|| ACTION_SECURE_STILL_IMAGE_CAMERA.equals(action)
120 | 				)
121 | 		{
122 | 			//REQUEST_TAKE_PICTURE
123 | 
124 | 			Intent intentCapture = new Intent(this,StillCameraActivity.class);
125 | 			intentCapture.setAction(MediaStore.ACTION_IMAGE_CAPTURE);
126 | 			intentCapture.putExtra("basepath", "/");
127 | 			intentCapture.putExtra("selfie", false);
128 | 			startActivityForResult(intentCapture, REQUEST_TAKE_PICTURE);
129 | 			isExternalLaunch = true;
130 | 		}		
131 | 		else if (MediaStore.ACTION_VIDEO_CAPTURE.equals(action)
132 | 				|| ACTION_SECURE_SECURE_VIDEO_CAMERA.equals(action)
133 | 				)
134 | 		{
135 | 			//REQUEST_TAKE_VIDEO
136 | 			Intent intentCapture = new Intent(this,VideoCameraActivity.class);
137 | 			intentCapture.setAction(MediaStore.ACTION_VIDEO_CAPTURE);
138 | 			intentCapture.putExtra("basepath", "/");
139 | 			intentCapture.putExtra("selfie", false);
140 | 			startActivityForResult(intentCapture, REQUEST_TAKE_VIDEO);
141 | 			isExternalLaunch = true;
142 | 			
143 | 		}
144 | 		
145 | 		setIntent(null);
146 | 		
147 | 	}
148 | 	
149 | 	 
150 | 	  @Override
151 | 	   public void onConfigurationChanged(Configuration newConfig) {
152 | 		  
153 | 		  	
154 | 	        super.onConfigurationChanged(newConfig);
155 | 
156 | 	   }
157 | 	 
158 | 	
159 | 	protected void onResume() {
160 | 		super.onResume();
161 | 		
162 | 		if (!StorageManager.isStorageMounted())
163 | 		{
164 | 			goToLockScreen ();
165 | 		}
166 | 		else
167 | 		{
168 | 			mCacheWord.reattach();
169 | 			
170 | 		}
171 | 		
172 | 	}
173 | 
174 | 	@Override
175 | 	public void onCacheWordLocked() {
176 | 	
177 | 		if (StorageManager.isStorageMounted())
178 | 		{
179 | 			//if storage is mounted, then we should lock it
180 | 			boolean unmounted = StorageManager.unmountStorage();
181 | 		}
182 | 		
183 | 		goToLockScreen ();
184 | 		
185 | 	}
186 | 
187 | 	@Override
188 | 	protected void onActivityResult(int requestCode, int resultCode, Intent data) {
189 | 		super.onActivityResult(requestCode, resultCode, data);
190 | 
191 |         if (requestCode == REQUEST_TAKE_PICTURE)
192 |         {
193 |         	 if (resultCode == RESULT_OK)
194 |              {
195 | 	        	String[] ioCipherFile = data.getExtras().getStringArray(MediaStore.EXTRA_OUTPUT);
196 | 	        	
197 | 	        	if (ioCipherFile != null && ioCipherFile.length > 0)
198 | 	        	{
199 | 	        		String sharePath = IOCipherContentProvider.addShare(ioCipherFile[0], IOCipherContentProvider.DEFAULT_AUTHORITY);
200 | 		        	Uri uri = Uri.parse(sharePath);	        		        
201 | 					String mimeType = "image/*";				
202 | 					data.setDataAndType(uri, mimeType);
203 | 					data.putExtra(Intent.EXTRA_STREAM, uri);					
204 | 					data.putExtra(MediaStore.EXTRA_OUTPUT, ioCipherFile);
205 | 
206 | 					setResult(resultCode,data);	
207 | 	        	}
208 |              }
209 |         	
210 |         }
211 |         else if (requestCode == REQUEST_TAKE_VIDEO)
212 |         {
213 |         	 if (resultCode == RESULT_OK)
214 |              {
215 | 	        	String[] ioCipherFile = data.getExtras().getStringArray(MediaStore.EXTRA_OUTPUT);
216 | 	        	
217 | 	        	if (ioCipherFile != null && ioCipherFile.length > 0)
218 | 	        	{
219 | 	        		String sharePath = IOCipherContentProvider.addShare(ioCipherFile[0], IOCipherContentProvider.DEFAULT_AUTHORITY);
220 | 		        	Uri uri = Uri.parse(sharePath);	  
221 | 					String mimeType = "video/*";				
222 | 					data.setDataAndType(uri, mimeType);
223 | 					data.putExtra(Intent.EXTRA_STREAM, uri);
224 | 					data.putExtra(MediaStore.EXTRA_OUTPUT, ioCipherFile);
225 | 
226 | 		        	setResult(resultCode,data);
227 | 	        	}
228 |              }
229 |         	 
230 |         }
231 |         
232 |         if (isExternalLaunch)
233 |         	finish();
234 |         else
235 |         	getFileList(root);
236 |         
237 |         
238 | 	}
239 | 
240 | 	@Override
241 | 	public void onCacheWordOpened() {
242 | 
243 |         mCacheWord.setTimeout(0);
244 | 		//great!
245 |         getFileList(root);
246 | 	}
247 | 
248 | 	@Override
249 | 	public void onCacheWordUninitialized() {
250 | 		
251 | 		goToLockScreen ();
252 | 		
253 | 	}
254 | 	
255 | 	private void goToLockScreen ()
256 | 	{
257 | 		try
258 | 		{
259 | 			mCacheWord.disconnectFromService();
260 | 		}
261 | 		catch (IllegalArgumentException iae)
262 | 		{
263 | 			Log.d(TAG,"error disconnecting from cacheword service",iae);
264 | 		}
265 | 		
266 | 		
267 | 		if (mUseBuiltInLockScreen && (!isExternalLaunch))
268 | 		{
269 | 			Intent intent = new Intent(this,LockScreenActivity.class);
270 | 			intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
271 | 			startActivity(intent);
272 | 			finish();
273 | 		}
274 | 		
275 | 	}
276 | 
277 | 	@Override
278 | 	protected void onPause() {
279 | 		super.onPause();
280 | 		
281 | 
282 | 		mCacheWord.detach();
283 | 		
284 | 	}
285 | 
286 | 	protected void onDestroy() {
287 | 		super.onDestroy();
288 | 		
289 | 		mCacheWord.disconnectFromService();
290 | 	}
291 | 	
292 | 	@Override
293 |     public boolean onCreateOptionsMenu(Menu menu) {
294 |         
295 |         MenuInflater inflater = getMenuInflater();
296 |         inflater.inflate(R.menu.main, menu);
297 |         
298 |         return true;
299 | 	}
300 | 	
301 | 
302 |     @Override
303 |     public boolean onOptionsItemSelected(MenuItem item) {
304 |     	
305 |     	Intent intent = null;
306 |     	
307 |         int itemId = item.getItemId();
308 |         
309 | 		if (itemId == R.id.menu_camera) {
310 | 			intent = new Intent(this,StillCameraActivity.class);
311 | 			intent.putExtra("basepath", "/");
312 | 			intent.putExtra("selfie", false);
313 | 			startActivityForResult(intent, 1);
314 | 			return true;
315 | 		} else if (itemId == R.id.menu_video) {
316 | 			intent = new Intent(this,VideoCameraActivity.class);
317 | 			intent.putExtra("basepath", "/");
318 | 			intent.putExtra("selfie", false);
319 | 			startActivityForResult(intent, 1);
320 | 			return true;
321 | 		} else if (itemId == R.id.menu_lock) {
322 | 			if (StorageManager.isStorageMounted())
323 |     		{
324 |     			//if storage is mounted, then we should lock it
325 |     			boolean unmounted = StorageManager.unmountStorage();
326 |     			
327 |     			if (!unmounted)    			
328 |     			{
329 |     				Toast.makeText(this, "Storage is busy... cannot lock yet.",Toast.LENGTH_LONG).show();
330 |     			}
331 |     			else
332 |     			{
333 |     				mCacheWord.lock();
334 |     			}
335 |     		}
336 | 			return true;
337 | 		}	
338 |         
339 | 		
340 |         return false;
341 |     }
342 | 
343 | 	private void handleSendUri(Uri dataUri) {
344 | 		try {
345 | 			ContentResolver cr = getContentResolver();
346 | 			InputStream in = cr.openInputStream(dataUri);
347 | 			Log.i(TAG, "incoming URI: " + dataUri.toString());
348 | 			String fileName = dataUri.getLastPathSegment();
349 | 			File f = new File("/" + fileName);
350 | 			BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(f));
351 | 			readBytesAndClose(in, out);
352 | 			Log.v(TAG, f.getAbsolutePath() + " size: " + String.valueOf(f.length()));
353 | 		} catch (Exception e) {
354 | 			Log.e(TAG, e.getMessage(), e);
355 | 		}
356 | 	}
357 | 
358 | 	private void readBytesAndClose(InputStream in, OutputStream out)
359 | 			throws IOException {
360 | 		try {
361 | 			int block = 8 * 1024; // IOCipher works best with 8k blocks
362 | 			byte[] buff = new byte[block];
363 | 			while (true) {
364 | 				int len = in.read(buff, 0, block);
365 | 				if (len < 0) {
366 | 					break;
367 | 				}
368 | 				out.write(buff, 0, len);
369 | 			}
370 | 		} finally {
371 | 			in.close();
372 | 			out.flush();
373 | 			out.close();
374 | 		}
375 | 	}
376 | 
377 | 	// To make listview for the list of file
378 | 	public void getFileList(String dirPath) {
379 | 
380 | 		item = new ArrayList<String>();
381 | 		path = new ArrayList<String>();
382 | 
383 | 		File file = new File(dirPath);
384 | 		File[] files = file.listFiles();
385 | 
386 | 		if (!dirPath.equals(root)) {
387 | 			item.add(root);
388 | 			path.add(root);// to get back to main list
389 | 
390 | 			item.add("..");
391 | 			path.add(file.getParent()); // back one level
392 | 		}
393 | 
394 | 		for (int i = files.length-1; i >= 0; i--) {
395 | 
396 | 			File fileItem = files[i];
397 | 			path.add(fileItem.getPath());
398 | 			if (fileItem.isDirectory()) {
399 | 				// input name directory to array list
400 | 				item.add("[" + fileItem.getName() + "]");
401 | 			} else {
402 | 				// input name file to array list
403 | 				item.add(fileItem.getName());
404 | 			}
405 | 		}
406 | 		
407 | 		// declare array with specific number of items
408 | 		items = new String[item.size()];
409 | 		// send data arraylist(item) to array(items)
410 | 		item.toArray(items);
411 | 	    gridview.setAdapter(new IconicList());
412 | 
413 | 	    gridview.setOnItemClickListener(new OnItemClickListener() {
414 | 	        public void onItemClick(AdapterView<?> parent, View v,
415 | 	                int position, long id) {
416 | 	    
417 | 					File file = new File(path.get(position));
418 | 					
419 | 					if (file.isDirectory()) {
420 | 							if (file.canRead()) {
421 | 								getFileList(path.get(position));
422 | 							} else {
423 | 								//show error
424 | 				
425 | 							}
426 | 					} else {
427 | 						showItem (file);
428 | 					}
429 | 	        }
430 | 					
431 | 	     });
432 | 	    
433 | 	    gridview.setOnItemLongClickListener(new OnItemLongClickListener () {
434 | 
435 | 			@Override
436 | 			public boolean onItemLongClick(AdapterView<?> arg0, View arg1,
437 | 					int position, long arg3) {
438 | 				
439 | 				File file = new File(path.get(position));
440 | 				if (file.isDirectory()) {
441 | 					if (file.canRead()) {
442 | 						getFileList(path.get(position));
443 | 						return true;
444 | 					} else {
445 | 						//show error
446 | 		
447 | 					}
448 | 				} else {
449 | 					showItemDialog (file);
450 | 					return true;
451 | 				}
452 | 				
453 | 				return false;
454 | 			}
455 | 	    	
456 | 	    });
457 | 	    
458 | 	}
459 | 	
460 | 	private void showItemDialog (final File file)
461 | 	{
462 | 		
463 | 		new AlertDialog.Builder(GalleryActivity.this)
464 | 				.setIcon(R.drawable.ic_launcher)
465 | 				.setTitle("[" + file.getName() + "]")
466 | 				.setNegativeButton("Delete",
467 | 						new DialogInterface.OnClickListener() {
468 | 					
469 | 						public void onClick(DialogInterface dialog,
470 | 							int which) {
471 | 							
472 | 							file.delete();
473 | 							getFileList(root);
474 | 						}
475 | 						
476 | 				})
477 | 				.setPositiveButton("Share...",
478 | 						new DialogInterface.OnClickListener() {
479 | 
480 | 							// @Override
481 | 							public void onClick(DialogInterface dialog,
482 | 									int which) {
483 | 								
484 | 								//Log.i(TAG,"open URL: " + Uri.parse(IOCipherContentProvider.FILES_URI + file.getName()));
485 | 								String sharePath = IOCipherContentProvider.addShare(file.getName(), IOCipherContentProvider.DEFAULT_AUTHORITY);
486 | 					        	Uri uri = Uri.parse(sharePath);	  
487 | 								
488 | 								
489 | 								//java.io.File exportFile = exportToDisk(file);
490 | 								//Uri uriExport = Uri.fromFile(exportFile);
491 | 								
492 | 								Intent intent = new Intent(Intent.ACTION_SEND);
493 | 								
494 | 								String fileExtension = MimeTypeMap.getFileExtensionFromUrl(uri.toString());
495 | 								String mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(fileExtension);
496 | 								if (fileExtension.equals("mp4")||fileExtension.equals("mkv")||fileExtension.equals("mov"))
497 | 									mimeType = "video/*";
498 | 								if (mimeType == null)
499 | 									mimeType = "application/octet-stream";
500 | 								
501 | 								intent.setDataAndType(uri, mimeType);
502 | 								intent.putExtra(Intent.EXTRA_STREAM, uri);
503 | 								intent.putExtra(Intent.EXTRA_SUBJECT, file.getName());
504 | 								intent.putExtra(Intent.EXTRA_TITLE, file.getName());
505 | 								
506 | 								try {
507 | 									startActivity(Intent.createChooser(intent, "Share this!"));
508 | 								} catch (ActivityNotFoundException e) {
509 | 									Log.e(TAG, "No relevant Activity found", e);
510 | 								}
511 | 							}
512 | 						}).show();
513 | 	}
514 | 	
515 | 	private void showItem (File file)
516 | 	{
517 | 		try {
518 | 			String fileExtension = MimeTypeMap.getFileExtensionFromUrl(file.getAbsolutePath());
519 | 			String mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(fileExtension);
520 | 			if (fileExtension.equals("ts"))
521 | 				mimeType = "application/mpeg*";
522 | 			
523 | 			if (mimeType == null)
524 | 				mimeType = "application/octet-stream";
525 | 
526 | 			if (mimeType.startsWith("image"))
527 | 			{
528 | 				 Intent intent = new Intent(GalleryActivity.this,ImageViewerActivity.class);
529 | 				  intent.setType(mimeType);
530 | 				  intent.putExtra("vfs", file.getAbsolutePath());
531 | 				  startActivity(intent);	
532 | 			}
533 | 			else if (fileExtension.equals("mp4") || mimeType.startsWith("video"))
534 | 			{
535 | 				Intent intent = new Intent(GalleryActivity.this,MjpegViewerActivity.class);
536 | 				  intent.setType(mimeType);
537 | 				  intent.putExtra("video", file.getAbsolutePath());
538 | 				  
539 | 				  startActivity(intent);	
540 | 				
541 | 			}
542 | 			else {
543 | 				
544 | 			  String sharePath = IOCipherContentProvider.addShare(file.getName(), IOCipherContentProvider.DEFAULT_AUTHORITY);
545 | 			  Uri uri = Uri.parse(sharePath);	  
546 | 				
547 | 	          Intent intent = new Intent(Intent.ACTION_VIEW);													
548 | 			  intent.setDataAndType(uri, mimeType);
549 | 			  startActivity(intent);
550 | 			}
551 | 			 
552 | 			
553 | 		} catch (ActivityNotFoundException e) {
554 | 			Log.e(TAG, "No relevant Activity found", e);
555 | 		}
556 | 	}
557 | 
558 | 	static class ViewHolder {
559 | 		  
560 | 		  ImageView icon;		  
561 | 		  
562 | 		}
563 | 	
564 | 	class IconicList extends ArrayAdapter<Object> {
565 | 
566 | 		public IconicList() {
567 | 			super(GalleryActivity.this, R.layout.gallery_gridsq, items);
568 | 		}
569 | 
570 | 		public View getView(int position, View convertView, ViewGroup parent) {
571 | 			LayoutInflater inflater = getLayoutInflater();
572 | 			
573 | 			ViewHolder holder = null;
574 | 			
575 | 			if (convertView == null)
576 | 				convertView = inflater.inflate(R.layout.gallery_gridsq, null);							
577 | 			else 
578 | 				holder = (ViewHolder)convertView.getTag();
579 | 			
580 | 			if (holder == null)
581 | 			{
582 | 				holder = new ViewHolder();
583 | 			
584 | 				holder.icon = (ImageView) convertView.findViewById(R.id.icon);
585 | 
586 | 				holder.icon.setImageResource(R.drawable.text);
587 | 			}
588 | 			
589 | 			
590 | 			File f = new File(path.get(position)); // get the file according the
591 | 												// position
592 | 		
593 | 			String mimeType = null;
594 | 
595 | 			String[] tokens = f.getName().split("\\.(?=[^\\.]+$)");
596 | 			
597 | 			if (tokens.length > 1)
598 | 				mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(f.getName().split("\\.")[1]);
599 | 			
600 | 			if (mimeType == null)
601 | 				mimeType = "application/octet-stream";
602 | 			
603 | 			if (f.isDirectory()) {
604 | 				holder.icon.setImageResource(R.drawable.folder);
605 | 			} else if (mimeType.startsWith("image")){
606 | 				
607 | 				try
608 | 				{
609 | 					Bitmap b = getPreview(f);
610 | 					if (b != null)
611 | 						holder.icon.setImageBitmap(b);
612 | 					else
613 | 						holder.icon.setImageResource(R.drawable.jpeg);//placeholder while its loading
614 | 				}
615 | 				catch (Exception e)
616 | 				{
617 | 					Log.d(TAG,"error showing thumbnail",e);
618 | 					holder.icon.setImageResource(R.drawable.text);	
619 | 				}
620 | 			}			
621 | 			else if (mimeType.startsWith("audio")||f.getName().endsWith(".pcm")||f.getName().endsWith(".aac"))
622 | 			{
623 | 				holder.icon.setImageResource(R.drawable.audio);
624 | 			}
625 | 			else if (mimeType.startsWith("video")||f.getName().endsWith(".mp4")||f.getName().endsWith(".mov"))
626 | 			{
627 | 				holder.icon.setImageResource(R.drawable.mp4);
628 | 			}
629 | 			else
630 | 			{
631 | 				holder.icon.setImageResource(R.drawable.text);
632 | 			}
633 | 				
634 | 			
635 | 			
636 | 			return (convertView);
637 | 		}
638 | 
639 | 	}
640 | 
641 | 	private Bitmap getPreview(File fileImage) throws FileNotFoundException {
642 | 
643 | 		Bitmap b = null;
644 | 		
645 | 		synchronized (mBitCache)
646 | 		{
647 | 			b = mBitCache.get(fileImage.getAbsolutePath());
648 | 			
649 | 			if (b == null && mBitLoaders.get(fileImage.getAbsolutePath())==null)
650 | 			{
651 | 				BitmapWorkerThread bwt = new BitmapWorkerThread(fileImage);
652 | 				mBitLoaders.put(fileImage.getAbsolutePath(),bwt);
653 | 				bwt.start();
654 | 				
655 | 			}
656 | 		}
657 | 		
658 | 		return b;
659 | 	}
660 | 	
661 | 	class BitmapWorkerThread extends Thread
662 | 	{
663 | 		private File fileImage;
664 | 		
665 | 		public BitmapWorkerThread (File fileImage)
666 | 		{
667 | 			this.fileImage = fileImage;
668 | 		}
669 | 		
670 | 		public void run ()
671 | 		{
672 | 			BitmapFactory.Options bounds = new BitmapFactory.Options();	    
673 | 			bounds.inSampleSize = 8;	 	    
674 | 			Bitmap b;
675 | 			try {
676 | 				FileInputStream fis = new FileInputStream(fileImage);
677 | 				b = BitmapFactory.decodeStream(fis, null, bounds);
678 | 				fis.close();
679 | 				mBitCache.put(fileImage.getAbsolutePath(), b);
680 | 				mBitLoaders.remove(fileImage.getAbsolutePath());
681 | 
682 | 				h.post(new Runnable()
683 | 				{
684 | 					public void run ()
685 | 					{
686 | 						((IconicList)gridview.getAdapter()).notifyDataSetChanged();
687 | 					}
688 | 				});
689 | 				
690 | 				//VirtualFileSystem.get().detachThread();
691 | 		    
692 | 			} catch (Exception e) {
693 | 				Log.e(TAG,"error decoding bitmap preview",e);
694 | 			}
695 | 		}
696 | 	}
697 | 	
698 | 	/*
699 | 	class BitmapWorkerTask extends AsyncTask<File, Void, Bitmap> {
700 | 
701 | 	    // Decode image in background.
702 | 	    @Override
703 | 	    protected Bitmap doInBackground(File... fileImage) {
704 | 
705 | 	        BitmapFactory.Options bounds = new BitmapFactory.Options();	    
706 | 			bounds.inSampleSize = 8;	 	    
707 | 			Bitmap b;
708 | 			try {
709 | 				FileInputStream fis = new FileInputStream(fileImage[0]);
710 | 				b = BitmapFactory.decodeStream(fis, null, bounds);
711 | 				fis.close();
712 | 				mBitCache.put(fileImage[0].getAbsolutePath(), b);
713 | 				
714 | 				return b;
715 | 			} catch (Exception e) {
716 | 				Log.e(TAG,"error decoding bitmap preview",e);
717 | 			}
718 | 			
719 | 	        return null;
720 | 	        
721 | 	    }
722 | 
723 | 	    // Once complete, see if ImageView is still around and set bitmap.
724 | 	    @Override
725 | 	    protected void onPostExecute(Bitmap bitmap) {	    	
726 | 	    	((IconicList)gridview.getAdapter()).notifyDataSetChanged();
727 | 			
728 | 	    }
729 | 	}*/
730 | 
731 | 
732 | 	 public void setUseBuiltInLockScreen(boolean useBuiltInLockScreen) {
733 | 		this.mUseBuiltInLockScreen = useBuiltInLockScreen;
734 | 	}
735 | 
736 | 
737 | 	
738 | }
739 | 


--------------------------------------------------------------------------------
/src/info/guardianproject/iocipher/camera/LockScreenActivity.java:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * 
  3 |  * This file contains code from the IOCipher Camera Library "CipherCam".
  4 |  *
  5 |  * For more information about IOCipher, see https://guardianproject.info/code/iocipher
  6 |  * and this sample library: https://github.com/n8fr8/IOCipherCameraExample
  7 |  *
  8 |  * IOCipher Camera Sample is distributed under this license (aka the 3-clause BSD license)
  9 |  *
 10 |  * @author n8fr8
 11 |  * 
 12 |  */
 13 | 
 14 | package info.guardianproject.iocipher.camera;
 15 | 
 16 | import info.guardianproject.cacheword.CacheWordHandler;
 17 | import info.guardianproject.cacheword.ICacheWordSubscriber;
 18 | 
 19 | import java.security.GeneralSecurityException;
 20 | 
 21 | import android.app.Activity;
 22 | import android.content.Intent;
 23 | import android.os.Bundle;
 24 | import android.os.Handler;
 25 | import android.os.ResultReceiver;
 26 | import android.util.Log;
 27 | import android.view.KeyEvent;
 28 | import android.view.View;
 29 | import android.view.View.OnClickListener;
 30 | import android.view.animation.Animation;
 31 | import android.view.animation.AnimationUtils;
 32 | import android.view.inputmethod.EditorInfo;
 33 | import android.view.inputmethod.InputMethodManager;
 34 | import android.widget.Button;
 35 | import android.widget.EditText;
 36 | import android.widget.LinearLayout;
 37 | import android.widget.TextView;
 38 | import android.widget.TextView.OnEditorActionListener;
 39 | import android.widget.Toast;
 40 | import android.widget.ViewFlipper;
 41 | 
 42 | public class LockScreenActivity extends Activity implements ICacheWordSubscriber {
 43 |     private static final String TAG = "LockScreenActivity";
 44 | 
 45 |     private EditText mEnterPassphrase;
 46 |     private EditText mNewPassphrase;
 47 |     private EditText mConfirmNewPassphrase;
 48 |     private View mViewCreatePassphrase;
 49 |     private View mViewEnterPassphrase;
 50 |  //   private Button mBtnOpen;
 51 |     private String mPasswordError;
 52 |     private TwoViewSlider mSlider;
 53 | 
 54 |     private CacheWordHandler mCacheWord;
 55 |     
 56 |     @Override
 57 |     protected void onCreate(Bundle savedInstanceState) {
 58 |         super.onCreate(savedInstanceState);
 59 |         setContentView(R.layout.activity_lock_screen);
 60 |        
 61 |         mViewCreatePassphrase = findViewById(R.id.llCreatePassphrase);
 62 |         mViewEnterPassphrase = findViewById(R.id.llEnterPassphrase);
 63 | 
 64 |         mEnterPassphrase = (EditText) findViewById(R.id.editEnterPassphrase);
 65 |         mNewPassphrase = (EditText) findViewById(R.id.editNewPassphrase);
 66 |         mConfirmNewPassphrase = (EditText) findViewById(R.id.editConfirmNewPassphrase);
 67 |         ViewFlipper vf = (ViewFlipper) findViewById(R.id.viewFlipper1);
 68 |         LinearLayout flipView1 = (LinearLayout) findViewById(R.id.flipView1);
 69 |         LinearLayout flipView2 = (LinearLayout) findViewById(R.id.flipView2);
 70 | 
 71 |         mSlider = new TwoViewSlider(vf, flipView1, flipView2, mNewPassphrase, mConfirmNewPassphrase);
 72 |         
 73 |         mCacheWord = new CacheWordHandler(this, this);
 74 |         mCacheWord.connectToService(); 
 75 |     }
 76 | 
 77 |     @Override
 78 |     protected void onPause() {
 79 |         super.onPause();
 80 |         mCacheWord.detach();
 81 |     }
 82 |     
 83 |     
 84 | 
 85 |     @Override
 86 | 	protected void onDestroy() {
 87 | 		super.onDestroy();
 88 | 		
 89 | 		mCacheWord.disconnectFromService();
 90 | 	}
 91 | 
 92 | 	@Override
 93 |     protected void onResume() {
 94 |         super.onResume();
 95 |         mCacheWord.reattach();
 96 |     }
 97 | 
 98 |     @Override
 99 |     public void onCacheWordUninitialized() {
100 |         initializePassphrase();
101 |     }
102 | 
103 |     @Override
104 |     public void onCacheWordLocked() {
105 |         promptPassphrase();
106 |     }
107 | 
108 |     @Override
109 |     public void onCacheWordOpened() {
110 | 
111 |     	StorageManager.mountStorage(this, null, mCacheWord.getEncryptionKey());
112 |     	
113 |     	Intent intent = new Intent(this,GalleryActivity.class);
114 |         intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP);
115 |         startActivity(intent);
116 |         finish();
117 |         overridePendingTransition(0, 0);
118 |     }
119 | 
120 |     private boolean newEqualsConfirmation() {
121 |         return mNewPassphrase.getText().toString()
122 |                 .equals(mConfirmNewPassphrase.getText().toString());
123 |     }
124 | 
125 |     private void showValidationError() {
126 |         Toast.makeText(LockScreenActivity.this, mPasswordError, Toast.LENGTH_LONG).show();
127 |         mNewPassphrase.requestFocus();
128 |     }
129 | 
130 |     private void showInequalityError() {
131 |         Toast.makeText(LockScreenActivity.this,
132 |                 R.string.lock_screen_passphrases_not_matching,
133 |                 Toast.LENGTH_SHORT).show();
134 |         clearNewFields();
135 |     }
136 | 
137 |     private void clearNewFields() {
138 |         mNewPassphrase.getEditableText().clear();
139 |         mConfirmNewPassphrase.getEditableText().clear();
140 |     }
141 | 
142 |     private boolean isPasswordValid() {
143 |     	boolean valid = mNewPassphrase.getText().toString().length() > 4;
144 |     	if(!valid)
145 |     		mPasswordError = getString(R.string.pass_err_length);
146 |         return valid;
147 |     }
148 | 
149 |     private boolean isConfirmationFieldEmpty() {
150 |         return mConfirmNewPassphrase.getText().toString().length() == 0;
151 |     }
152 | 
153 |     private void initializePassphrase() {
154 |         // Passphrase is not set, so allow the user to create one
155 | 
156 |         mViewCreatePassphrase.setVisibility(View.VISIBLE);
157 |         mViewEnterPassphrase.setVisibility(View.GONE);
158 | 
159 |         mNewPassphrase.setOnEditorActionListener(new OnEditorActionListener() {
160 | 
161 |             @Override
162 |             public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
163 |                 if (actionId == EditorInfo.IME_NULL || actionId == EditorInfo.IME_ACTION_DONE) {
164 |                     if (!isPasswordValid())
165 |                         showValidationError();
166 |                     else
167 |                         mSlider.showConfirmationField();
168 |                 }
169 |                 return false;
170 |             }
171 |         });
172 | 
173 |         mConfirmNewPassphrase.setOnEditorActionListener(new OnEditorActionListener() {
174 | 
175 |             @Override
176 |             public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
177 |                 if (actionId == EditorInfo.IME_NULL || actionId == EditorInfo.IME_ACTION_DONE) {
178 |                     if (!newEqualsConfirmation()) {
179 |                         showInequalityError();
180 |                         mSlider.showNewPasswordField();
181 |                     }
182 |                     else {
183 |                         try {
184 |                             mCacheWord.setPassphrase(mNewPassphrase.getText().toString().toCharArray());                        
185 |                         } catch (GeneralSecurityException e) {
186 |                             Log.e(TAG, "Cacheword pass initialization failed: " + e.getMessage());
187 |                         }
188 |                     }
189 |                 }
190 |                 return false;
191 |             }
192 |         });
193 | 
194 |         /*
195 |         Button btnCreate = (Button) findViewById(R.id.btnCreate);
196 |         btnCreate.setOnClickListener(new OnClickListener()
197 |         {
198 |             @Override
199 |             public void onClick(View v) {
200 |                 // validate
201 |                 if (!isPasswordValid()) {
202 |                     showValidationError();
203 |                     mSlider.showNewPasswordField();
204 |                 } else if (isConfirmationFieldEmpty()) {
205 |                     mSlider.showConfirmationField();
206 |                 } else if (!newEqualsConfirmation()) {
207 |                     showInequalityError();
208 |                     mSlider.showNewPasswordField();
209 |                 } else {
210 |                     try {
211 |                         mCacheWord.setPassphrase(mNewPassphrase.getText().toString().toCharArray());                        
212 |                     } catch (GeneralSecurityException e) {
213 |                         Log.e(TAG, "Cacheword pass initialization failed: " + e.getMessage());
214 |                     }
215 |                 }
216 |             }
217 |         });*/
218 |     }
219 | 
220 |     private void promptPassphrase() {
221 |         mViewCreatePassphrase.setVisibility(View.GONE);
222 |         mViewEnterPassphrase.setVisibility(View.VISIBLE);
223 | 
224 |         /*
225 |         mBtnOpen = (Button) findViewById(R.id.btnOpen);
226 |         mBtnOpen.setOnClickListener(new OnClickListener() {
227 |             @Override
228 |             public void onClick(View v) {
229 |                 if (mEnterPassphrase.getText().toString().length() == 0)
230 |                     return;
231 |                 // Check passphrase
232 |                 try {
233 |                     mCacheWord.setPassphrase(mEnterPassphrase.getText().toString().toCharArray());
234 |                 } catch (GeneralSecurityException e) {
235 |                     mEnterPassphrase.setText("");
236 |                     Log.e(TAG, "Cacheword pass verification failed: " + e.getMessage());
237 |                     return;
238 |                 }
239 |             }
240 |         });*/
241 | 
242 |         mEnterPassphrase.setOnEditorActionListener(new OnEditorActionListener()
243 |         {
244 |             @Override
245 |             public boolean onEditorAction(TextView v, int actionId, KeyEvent event)
246 |             {
247 |                 if (actionId == EditorInfo.IME_NULL || actionId == EditorInfo.IME_ACTION_GO)
248 |                 {
249 |                     InputMethodManager imm = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE);
250 |                     Handler threadHandler = new Handler();
251 |                     imm.hideSoftInputFromWindow(v.getWindowToken(), 0, new ResultReceiver(
252 |                             threadHandler)
253 |                     {
254 |                         @Override
255 |                         protected void onReceiveResult(int resultCode, Bundle resultData) {
256 |                             super.onReceiveResult(resultCode, resultData);
257 |                             if (mEnterPassphrase.getText().toString().length() == 0)
258 |                                 return;
259 |                             // Check passphrase
260 |                             try {
261 |                                 mCacheWord.setPassphrase(mEnterPassphrase.getText().toString().toCharArray());
262 |                             } catch (GeneralSecurityException e) {
263 |                                 mEnterPassphrase.setText("");
264 |                                 Log.e(TAG, "Cacheword pass verification failed: " + e.getMessage());
265 |                                 return;
266 |                             }
267 |                         }
268 |                     });
269 |                     return true;
270 |                 }
271 |                 return false;
272 |             }
273 |         });
274 |     }
275 | 
276 |     public class TwoViewSlider {
277 | 
278 |         private boolean firstIsShown = true;
279 |         private ViewFlipper flipper;
280 |         private LinearLayout container1;
281 |         private LinearLayout container2;
282 |         private View firstView;
283 |         private View secondView;
284 |         
285 |         public TwoViewSlider(ViewFlipper flipper, LinearLayout container1, LinearLayout container2,
286 |                 View view1, View view2) {
287 |             this.flipper = flipper;
288 |             this.container1 = container1;
289 |             this.container2 = container2;
290 |             this.firstView = view1;
291 |             this.secondView = view2;
292 | 
293 |         }
294 | 
295 |         public void showNewPasswordField() {
296 |             if (firstIsShown)
297 |                 return;
298 | 
299 |             flip();
300 |         }
301 | 
302 |         public void showConfirmationField() {
303 |             if (!firstIsShown)
304 |                 return;
305 | 
306 |             flip();
307 |         }
308 | 
309 |         private void flip() {
310 |             if (firstIsShown) {
311 |                 firstIsShown = false;
312 |                 container2.removeAllViews();
313 |                 container2.addView(secondView);
314 |             } else {
315 |                 firstIsShown = true;
316 |                 container1.removeAllViews();
317 |                 container1.addView(firstView);
318 |             }
319 |             flipper.showNext();
320 |         }
321 |     }
322 | }
323 | 


--------------------------------------------------------------------------------
/src/info/guardianproject/iocipher/camera/MediaConstants.java:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * 
 3 |  * This file contains code from the IOCipher Camera Library "CipherCam".
 4 |  *
 5 |  * For more information about IOCipher, see https://guardianproject.info/code/iocipher
 6 |  * and this sample library: https://github.com/n8fr8/IOCipherCameraExample
 7 |  *
 8 |  * IOCipher Camera Sample is distributed under this license (aka the 3-clause BSD license)
 9 |  *
10 |  * @author n8fr8
11 |  * 
12 |  */
13 | 
14 | package info.guardianproject.iocipher.camera;
15 | 
16 | import android.media.AudioFormat;
17 | 
18 | public class MediaConstants {
19 | 
20 | 	public static int sJpegQuality = 50; //70 is the quality!
21 | 	public static int sPreviewWidth = 720; //defualt width
22 | 	public static int sPreviewHeight = 480; //default height "480p"
23 | 	
24 | 	public static int sAudioSampleRate = 11025; //keep it low for now
25 | 	public static int sAudioChannels = 1;
26 | 	public static int sAudioBitRate = 64;
27 | 
28 | 	public static int sChannelConfigIn = AudioFormat.CHANNEL_IN_MONO;
29 | 	public static int sChannelConfigOut = AudioFormat.CHANNEL_OUT_MONO;
30 | }
31 | 


--------------------------------------------------------------------------------
/src/info/guardianproject/iocipher/camera/StillCameraActivity.java:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * 
 3 |  * This file contains code from the IOCipher Camera Library "CipherCam".
 4 |  *
 5 |  * For more information about IOCipher, see https://guardianproject.info/code/iocipher
 6 |  * and this sample library: https://github.com/n8fr8/IOCipherCameraExample
 7 |  *
 8 |  * IOCipher Camera Sample is distributed under this license (aka the 3-clause BSD license)
 9 |  *
10 |  * @author n8fr8
11 |  * 
12 |  */
13 | 
14 | package info.guardianproject.iocipher.camera;
15 | 
16 | import info.guardianproject.iocipher.File;
17 | import info.guardianproject.iocipher.FileOutputStream;
18 | 
19 | import java.io.BufferedOutputStream;
20 | import java.util.ArrayList;
21 | 
22 | import android.app.Activity;
23 | import android.content.Intent;
24 | import android.graphics.Color;
25 | import android.hardware.Camera;
26 | import android.os.Bundle;
27 | import android.provider.MediaStore;
28 | 
29 | public class StillCameraActivity extends CameraBaseActivity {
30 | 	
31 | 	private String mFileBasePath = null;
32 | 	
33 | 	private boolean isRequest = false;
34 | 	private ArrayList<String> mResultList = null;
35 | 	
36 | 	@Override
37 | 	public void onCreate(Bundle savedInstanceState) {
38 | 		super.onCreate(savedInstanceState);
39 | 		mFileBasePath = getIntent().getStringExtra("basepath");
40 | 		
41 | 		isRequest = getIntent().getAction() != null && getIntent().getAction().equals(MediaStore.ACTION_IMAGE_CAPTURE);
42 | 		mResultList = new ArrayList<String>();
43 | 
44 | 		button.setBackgroundResource(R.drawable.ic_action_camera);
45 | 		buttonSelfie.setBackgroundResource(R.drawable.ic_action_switch_camera);
46 | 	}
47 | 
48 | 	@Override
49 | 	public void onPictureTaken(final byte[] data, Camera camera) {		
50 | 		File fileSecurePicture;
51 | 		try {
52 | 			
53 | 			if (overlayView != null)
54 | 				overlayView.setBackgroundResource(R.color.flash);
55 | 			
56 | 			long mTime = System.currentTimeMillis();
57 | 			fileSecurePicture = new File(mFileBasePath,"secure_image_" + mTime + ".jpg");
58 | 
59 | 			BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(fileSecurePicture));
60 | 			out.write(data);
61 | 			out.flush();
62 | 			out.close();
63 | 
64 | 			mResultList.add(fileSecurePicture.getAbsolutePath());
65 | 
66 | 			Intent intentResult = new Intent().putExtra(MediaStore.EXTRA_OUTPUT, mResultList.toArray(new String[mResultList.size()]));			
67 | 			setResult(Activity.RESULT_OK, intentResult);
68 | 			
69 | 			view.postDelayed(new Runnable()
70 | 			{
71 | 				@Override
72 | 				public void run() {
73 | 					overlayView.setBackgroundColor(Color.TRANSPARENT);
74 | 					
75 | 					resumePreview();
76 | 				}
77 | 			},100);
78 | 			
79 | 
80 | 		} catch (Exception e) {
81 | 			e.printStackTrace();
82 | 			setResult(Activity.RESULT_CANCELED);
83 | 
84 | 		}
85 | 
86 | 	}
87 | 
88 | 	@Override
89 | 	public void onPause() {
90 | 
91 | 		super.onPause();
92 | 
93 | 	}
94 | 	
95 | 	
96 | 
97 | }
98 | 


--------------------------------------------------------------------------------
/src/info/guardianproject/iocipher/camera/StorageManager.java:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * 
 3 |  * This file contains code from the IOCipher Camera Library "CipherCam".
 4 |  *
 5 |  * For more information about IOCipher, see https://guardianproject.info/code/iocipher
 6 |  * and this sample library: https://github.com/n8fr8/IOCipherCameraExample
 7 |  *
 8 |  * IOCipher Camera Sample is distributed under this license (aka the 3-clause BSD license)
 9 |  *
10 |  * @author n8fr8
11 |  * 
12 |  */
13 | 
14 | package info.guardianproject.iocipher.camera;
15 | 
16 | import info.guardianproject.iocipher.VirtualFileSystem;
17 | 
18 | import java.io.File;
19 | import java.io.IOException;
20 | 
21 | import android.content.Context;
22 | import android.os.Environment;
23 | import android.util.Log;
24 | 
25 | public class StorageManager {
26 | 
27 | 	private final static String DEFAULT_PATH = "gallery.db";
28 | 	
29 | 	public static boolean isStorageMounted ()
30 | 	{
31 | 		return VirtualFileSystem.get().isMounted();
32 | 	}
33 | 	
34 | 	public static boolean unmountStorage ()
35 | 	{
36 | 		try
37 | 		{
38 | 			VirtualFileSystem.get().unmount();
39 | 			return true;
40 | 		}
41 | 		catch (IllegalStateException ise)
42 | 		{
43 | 			Log.d("IOCipher","error unmounting - still active?",ise);
44 | 			return false;
45 | 		}
46 | 	}
47 | 	
48 | 	public static boolean mountStorage (Context context, String storagePath, byte[] passphrase)
49 | 	{
50 | 		File dbFile = null;
51 | 		
52 | 		if (storagePath == null)
53 | 		{
54 | 			dbFile = new java.io.File(context.getDir("vfs", Context.MODE_PRIVATE),DEFAULT_PATH);
55 | 		}
56 | 		else
57 | 		{
58 | 			dbFile = new java.io.File(storagePath);
59 | 		}
60 | 		dbFile.getParentFile().mkdirs();
61 | 		
62 | 		if (!dbFile.exists())
63 | 			VirtualFileSystem.get().createNewContainer(dbFile.getAbsolutePath(), passphrase);
64 | 		
65 | 
66 | 		if (!VirtualFileSystem.get().isMounted())
67 | 		{
68 | 			// TODO don't use a hard-coded password! prompt for the password
69 | 			VirtualFileSystem.get().mount(dbFile.getAbsolutePath(),passphrase);
70 | 		}
71 | 		
72 | 		
73 | 		return true;
74 | 	}
75 | 	
76 | 	public static java.io.File exportToDisk (info.guardianproject.iocipher.File fileIn) throws IOException
77 | 	{
78 | 		java.io.File fileOut = null;
79 | 		
80 | 		fileOut = new java.io.File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS),fileIn.getName());
81 | 		info.guardianproject.iocipher.FileInputStream fis = new info.guardianproject.iocipher.FileInputStream(fileIn);		
82 | 		java.io.FileOutputStream fos = new java.io.FileOutputStream(fileOut);
83 | 		
84 | 		byte[] b = new byte[4096];
85 | 		int len;
86 | 		while ((len = fis.read(b))!=-1)
87 | 		{
88 | 			fos.write(b, 0, len);
89 | 		}
90 | 		
91 | 		fis.close();
92 | 		fos.flush();
93 | 		fos.close();
94 | 		
95 | 		return fileOut;
96 | 		
97 | 	}
98 | }
99 | 


--------------------------------------------------------------------------------
/src/info/guardianproject/iocipher/camera/VideoCameraActivity.java:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * 
  3 |  * This file contains code from the IOCipher Camera Library "CipherCam".
  4 |  *
  5 |  * For more information about IOCipher, see https://guardianproject.info/code/iocipher
  6 |  * and this sample library: https://github.com/n8fr8/IOCipherCameraExample
  7 |  *
  8 |  * IOCipher Camera Sample is distributed under this license (aka the 3-clause BSD license)
  9 |  *
 10 |  * @author n8fr8
 11 |  * 
 12 |  */
 13 | 
 14 | package info.guardianproject.iocipher.camera;
 15 | 
 16 | import info.guardianproject.iocipher.File;
 17 | import info.guardianproject.iocipher.FileInputStream;
 18 | import info.guardianproject.iocipher.FileOutputStream;
 19 | import info.guardianproject.iocipher.camera.encoders.AACHelper;
 20 | import info.guardianproject.iocipher.camera.encoders.ImageToMJPEGMOVMuxer;
 21 | import info.guardianproject.iocipher.camera.io.IOCipherFileChannelWrapper;
 22 | 
 23 | import java.io.BufferedOutputStream;
 24 | import java.io.ByteArrayOutputStream;
 25 | import java.io.FileNotFoundException;
 26 | import java.io.IOException;
 27 | import java.io.OutputStream;
 28 | import java.nio.ByteBuffer;
 29 | import java.util.ArrayDeque;
 30 | import java.util.ArrayList;
 31 | 
 32 | import org.jcodec.common.ArrayUtil;
 33 | import org.jcodec.common.SeekableByteChannel;
 34 | 
 35 | import android.app.Activity;
 36 | import android.content.Intent;
 37 | import android.content.res.Configuration;
 38 | import android.graphics.Color;
 39 | import android.graphics.Rect;
 40 | import android.graphics.YuvImage;
 41 | import android.hardware.Camera;
 42 | import android.hardware.Camera.CameraInfo;
 43 | import android.media.AudioFormat;
 44 | import android.media.AudioRecord;
 45 | import android.media.MediaRecorder;
 46 | import android.os.Bundle;
 47 | import android.os.Handler;
 48 | import android.os.Message;
 49 | import android.provider.MediaStore;
 50 | import android.util.Log;
 51 | import android.view.MotionEvent;
 52 | import android.view.View;
 53 | import android.widget.Toast;
 54 | 
 55 | public class VideoCameraActivity extends CameraBaseActivity {
 56 | 	
 57 | 	private final static String LOG = "VideoJPEGRecorder";
 58 | 	
 59 | 	private String mFileBasePath = null;
 60 | 	private boolean mIsRecording = false;
 61 | 	
 62 | 	private ArrayDeque<VideoFrame> mFrameQ = null;
 63 | 	
 64 | 	private int mLastWidth = -1;
 65 | 	private int mLastHeight = -1;
 66 | 	private int mPreviewFormat = -1;
 67 | 
 68 | 	private ImageToMJPEGMOVMuxer muxer;
 69 | 	
 70 | 	private AACHelper aac;
 71 | 	private boolean useAAC = false;
 72 | 	private byte[] audioData;
 73 | 	private AudioRecord audioRecord;
 74 | 	
 75 | 	private boolean mPreCompressFrames = true;
 76 | 	private OutputStream outputStreamAudio;
 77 | 	private info.guardianproject.iocipher.File fileAudio;
 78 | 
 79 | 	private int mFpsCounter = 0;
 80 | 	private long start = 0;
 81 | 	private long lastTime = 0;
 82 | 	private int mFramesTotal = 0;
 83 | 	private int mFPS = 15; //default is 15fps
 84 | 	
 85 | 	private boolean isRequest = false;
 86 | 	private ArrayList<String> mResultList = null;
 87 | 
 88 | 	private boolean mInTopHalf = false;
 89 | 
 90 | 	private info.guardianproject.iocipher.File fileOut;
 91 | 	
 92 | 	@Override
 93 | 	public void onCreate(Bundle savedInstanceState) {
 94 | 		
 95 | 		super.onCreate(savedInstanceState);
 96 | 		
 97 | 		mFileBasePath = getIntent().getStringExtra("basepath");
 98 | 		
 99 | 		isRequest = getIntent().getAction() != null && getIntent().getAction().equals(MediaStore.ACTION_VIDEO_CAPTURE);
100 | 		mResultList = new ArrayList<String>();
101 | 	}
102 | 
103 | 	@Override
104 | 	protected int getLayout()
105 | 	{
106 | 		return R.layout.base_camera;
107 | 	}
108 | 
109 | 	private float mDownX = -1,mLastX = -1;
110 | 	private float mDownY = -1,mLastY=-1;
111 | 	private boolean mIsOnClick = false;
112 | 	private final float SCROLL_THRESHOLD = 10;
113 | 
114 | 	@Override
115 | 	public boolean onTouch(View v, MotionEvent ev) {
116 | 		
117 | 		//if short tap then take a picture
118 | 		
119 | 		//if long and hold then start video, then end on release
120 | 		
121 | 		//if location is on top half then front camera, on bottom have then back camera
122 | 		
123 | 		switch (ev.getAction() & MotionEvent.ACTION_MASK) {
124 |         case MotionEvent.ACTION_DOWN:
125 |             mDownX = ev.getX();
126 |             mDownY = ev.getY();
127 |             mIsOnClick = true;
128 |             handler.postDelayed(mLongPressed, 1000);
129 |             
130 |             mInTopHalf = mDownY < (mLastHeight/2);
131 | 
132 |             toggleCamera(mInTopHalf);
133 |             
134 |             break;
135 |         case MotionEvent.ACTION_CANCEL:
136 |         case MotionEvent.ACTION_UP:
137 |             if (!mIsRecording) {
138 |                
139 |             	//take a picture
140 |         		mPreviewing = false;
141 |         		camera.takePicture(null, null, this);
142 |                 handler.removeCallbacks(mLongPressed);
143 |             	
144 |             }
145 |             else
146 |             {
147 |             	stopRecording();
148 |             }
149 |             
150 |             break;
151 |         case MotionEvent.ACTION_MOVE:
152 |         	
153 |         	mLastX = ev.getX();
154 |         	mLastY = ev.getY();
155 |         	
156 |             
157 |             mInTopHalf = mLastY < (mDownY-100);
158 | 
159 |             toggleCamera(mInTopHalf);
160 |             
161 |             if (mIsOnClick && (Math.abs(mDownX - ev.getX()) > SCROLL_THRESHOLD || Math.abs(mDownY - ev.getY()) > SCROLL_THRESHOLD)) {
162 |                 mIsOnClick = false;
163 |                 
164 |             }
165 |             break;
166 |         default:
167 |             break;
168 | 	    }
169 | 	    return true;
170 | 		
171 | 	}
172 | 	
173 | 	final Handler handler = new Handler(); 
174 | 	Runnable mLongPressed = new Runnable() { 
175 | 	    public void run() { 
176 | 	        Log.i("", "Long press!");
177 | 	        
178 | 	        startRecording();
179 | 	        
180 | 	    }   
181 | 	};
182 | 
183 | 	
184 | 	@Override
185 | 	public void onClick(View view) {
186 | 		
187 | 		if (view == button)
188 | 		{
189 | 			if (!mIsRecording)
190 | 			{
191 | 				
192 | 				startRecording();
193 | 				
194 | 				
195 | 			}
196 | 			else
197 | 			{
198 | 				stopRecording ();
199 | 			}
200 | 		}
201 | 		
202 | 	}
203 | 	
204 | 	
205 | 	private void startRecording ()
206 | 	{
207 | 		mFrameQ = new ArrayDeque<VideoFrame>();
208 | 		
209 | 		mFramesTotal = 0;
210 | 		mFpsCounter = 0;
211 | 		
212 | 		lastTime = System.currentTimeMillis();
213 | 		
214 | 		String fileName = "video" + new java.util.Date().getTime() + ".mp4";
215 | 		fileOut = new info.guardianproject.iocipher.File(mFileBasePath,fileName);
216 | 		
217 | 		mResultList.add(fileOut.getAbsolutePath());
218 | 		Intent intentResult = new Intent().putExtra(MediaStore.EXTRA_OUTPUT, mResultList.toArray(new String[mResultList.size()]));			
219 | 		setResult(Activity.RESULT_OK, intentResult);
220 | 
221 | 		try {
222 | 			mIsRecording = true;
223 | 			
224 | 			if (useAAC)
225 | 				initAudio(fileOut.getAbsolutePath()+".aac");
226 | 			else
227 | 				initAudio(fileOut.getAbsolutePath()+".pcm");
228 | 			
229 | 			boolean withEmbeddedAudio = true;
230 | 			
231 | 			Encoder encoder = new Encoder(fileOut,mFPS,withEmbeddedAudio);
232 | 			encoder.start();
233 | 			//start capture
234 | 			startAudioRecording();
235 | 			
236 | 			progress.setText("[REC]");
237 | 
238 | 		} catch (Exception e) {
239 | 			Log.d("Video","error starting video",e);
240 | 			Toast.makeText(this, "Error init'ing video: " + e.getLocalizedMessage(), Toast.LENGTH_LONG).show();
241 | 			finish();
242 | 		}
243 | 	}
244 | 	
245 | 	private void stopRecording ()
246 | 	{
247 | 		progress.setText("[SAVING]");
248 | 		h.sendEmptyMessageDelayed(1, 2000);
249 | 		progress.setText("");
250 | 		
251 | 	}
252 | 	
253 | 	private void toggleCamera (boolean isSelfie)
254 | 	{
255 | 		if (isSelfie != mIsSelfie)
256 | 		{
257 | 			mIsSelfie = isSelfie;
258 | 			releaseCamera();
259 | 			initCamera();
260 | 		}
261 | 	}
262 | 
263 | 	//support still pictures if you tap on the screen
264 | 	@Override
265 | 	public void onPictureTaken(final byte[] data, Camera camera) {		
266 | 		File fileSecurePicture;
267 | 		try {
268 | 
269 | 			overlayView.setBackgroundResource(R.color.flash);
270 | 			
271 | 			long mTime = System.currentTimeMillis();
272 | 			fileSecurePicture = new File(mFileBasePath,"secureselfie_" + mTime + ".jpg");
273 | 
274 | 			BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(fileSecurePicture));
275 | 			out.write(data);
276 | 			out.flush();
277 | 			out.close();
278 | 
279 | 			mResultList.add(fileSecurePicture.getAbsolutePath());
280 | 
281 | 			Intent intentResult = new Intent().putExtra(MediaStore.EXTRA_OUTPUT, mResultList.toArray(new String[mResultList.size()]));			
282 | 			setResult(Activity.RESULT_OK, intentResult);
283 | 			
284 | 			view.postDelayed(new Runnable()
285 | 			{
286 | 				@Override
287 | 				public void run() {
288 | 					overlayView.setBackgroundColor(Color.TRANSPARENT);
289 | 					resumePreview();
290 | 				}
291 | 			},100);
292 | 
293 | 		} catch (Exception e) {
294 | 			e.printStackTrace();
295 | 			setResult(Activity.RESULT_CANCELED);
296 | 
297 | 		}
298 | 
299 | 	}
300 | 	
301 | 	@Override
302 | 	public void onPreviewFrame(byte[] data, Camera camera) {
303 | 		
304 | 		//even when not recording, we'll compress frames in order to estimate our FPS
305 | 		
306 | 	    Camera.Parameters parameters = camera.getParameters();
307 | 	    mLastWidth = parameters.getPreviewSize().width;
308 | 	    mLastHeight = parameters.getPreviewSize().height;
309 | 	    
310 | 		if (mRotation > 0) //flip height and width
311 | 		{
312 | 			mLastWidth =parameters.getPreviewSize().height;
313 | 			mLastHeight =parameters.getPreviewSize().width;
314 | 		}
315 | 	    
316 | 	    mPreviewFormat = parameters.getPreviewFormat();
317 | 	    
318 | 	    byte[] dataResult = data;
319 | 		
320 | 		if (mPreCompressFrames)
321 | 		{
322 | 			if (mRotation > 0)
323 | 			{
324 | 				dataResult = rotateYUV420Degree90(data,mLastHeight,mLastWidth);
325 | 				
326 | 				 if (getCameraDirection() == CameraInfo.CAMERA_FACING_FRONT)
327 | 				 {						 
328 | 					 dataResult = rotateYUV420Degree90(dataResult,mLastWidth,mLastHeight);
329 | 					 dataResult = rotateYUV420Degree90(dataResult,mLastHeight,mLastWidth);						 
330 | 				 }
331 | 				
332 | 			}
333 | 			
334 | 			YuvImage yuv = new YuvImage(dataResult, mPreviewFormat, mLastWidth, mLastHeight, null);
335 | 		    ByteArrayOutputStream out = new ByteArrayOutputStream();
336 | 		    yuv.compressToJpeg(new Rect(0, 0, mLastWidth, mLastHeight), MediaConstants.sJpegQuality, out);				    
337 | 		    dataResult = out.toByteArray();
338 | 		}   
339 | 		
340 | 		if (mFramesTotal == 0 && fileOut != null)
341 | 		{
342 | 			try {
343 | 				info.guardianproject.iocipher.FileOutputStream fosThumb = new info.guardianproject.iocipher.FileOutputStream(new info.guardianproject.iocipher.File(fileOut.getAbsolutePath() + ".thumb.jpg"));
344 | 				fosThumb.write(dataResult);
345 | 				fosThumb.flush();
346 | 				fosThumb.close();
347 | 			
348 | 			} catch (Exception e) {
349 | 
350 | 				Log.e("VideoCam","can't save thumb",e);
351 | 			}
352 | 		}
353 | 		
354 | 		if (mIsRecording && mFrameQ != null)
355 | 			synchronized (mFrameQ)
356 | 			{
357 | 				if (data != null)
358 | 				{
359 | 					
360 | 					VideoFrame vf = new VideoFrame();
361 | 					vf.image = dataResult;
362 | 					vf.duration = 1;//this is frame duration, not time //System.currentTimeMillis() - lastTime;
363 | 					vf.fps = mFPS;
364 | 					
365 | 					mFrameQ.add(vf);
366 | 					
367 | 					mFramesTotal++;					
368 | 					
369 | 				}
370 | 			}
371 | 			
372 | 		mFpsCounter++;
373 |         if((System.currentTimeMillis() - start) >= 1000) {
374 |         	mFPS = mFpsCounter;
375 |         	mFpsCounter = 0; 
376 |             start = System.currentTimeMillis();
377 |         }
378 | 		
379 | 	}
380 | 	
381 | 	private byte[] rotateYUV420Degree90(byte[] data, int imageWidth, int imageHeight) 
382 | 	{
383 | 	    byte [] yuv = new byte[imageWidth*imageHeight*3/2];
384 | 	    // Rotate the Y luma
385 | 	    int i = 0;
386 | 	    for(int x = 0;x < imageWidth;x++)
387 | 	    {
388 | 	        for(int y = imageHeight-1;y >= 0;y--)                               
389 | 	        {
390 | 	            yuv[i] = data[y*imageWidth+x];
391 | 	            i++;
392 | 	        }
393 | 	    }
394 | 	    // Rotate the U and V color components 
395 | 	    i = imageWidth*imageHeight*3/2-1;
396 | 	    for(int x = imageWidth-1;x > 0;x=x-2)
397 | 	    {
398 | 	        for(int y = 0;y < imageHeight/2;y++)                                
399 | 	        {
400 | 	            yuv[i] = data[(imageWidth*imageHeight)+(y*imageWidth)+x];
401 | 	            i--;
402 | 	            yuv[i] = data[(imageWidth*imageHeight)+(y*imageWidth)+(x-1)];
403 | 	            i--;
404 | 	        }
405 | 	    }
406 | 	    return yuv;
407 | 	}
408 | 
409 | 	private class VideoFrame 
410 | 	{
411 | 		byte[] image;
412 | 		long fps;
413 | 		long duration;
414 | 	}
415 | 	
416 | 	private class Encoder extends Thread {
417 | 		private static final String TAG = "ENCODER";
418 | 
419 | 		private File fileOut;
420 | 		private FileOutputStream fos;
421 | 		
422 | 		public Encoder (File fileOut, int baseFramesPerSecond, boolean withEmbeddedAudio) throws IOException
423 | 		{
424 | 			this.fileOut = fileOut;
425 | 
426 | 			fos = new info.guardianproject.iocipher.FileOutputStream(fileOut);
427 | 			SeekableByteChannel sbc = new IOCipherFileChannelWrapper(fos.getChannel());
428 | 
429 | 			org.jcodec.common.AudioFormat af = null;
430 | 			
431 | 			if (withEmbeddedAudio)
432 | 				af = new org.jcodec.common.AudioFormat(org.jcodec.common.AudioFormat.MONO_S16_LE(MediaConstants.sAudioSampleRate));
433 | 			
434 | 			muxer = new ImageToMJPEGMOVMuxer(sbc,af,baseFramesPerSecond);			
435 | 		}
436 | 		
437 | 		public void run ()
438 | 		{
439 | 
440 | 			try {
441 | 				
442 | 				while (mIsRecording || (!mFrameQ.isEmpty()))
443 | 				{
444 | 					if (mFrameQ.peek() != null)
445 | 					{
446 | 						VideoFrame vf = mFrameQ.pop();
447 | 						
448 | 						muxer.addFrame(mLastWidth, mLastHeight, ByteBuffer.wrap(vf.image),vf.fps,vf.duration);	
449 | 						
450 | 					}
451 | 
452 | 				}
453 | 				
454 | 				//now write audio
455 | 				
456 |             	FileInputStream fis = new FileInputStream(fileAudio);
457 |             	byte[] audioBuffer = new byte[1024*64];
458 |             	int bytesRead = -1;
459 |             	
460 |             	while ((bytesRead = fis.read(audioBuffer))!=-1)
461 |             	{
462 |             		muxer.addAudio(ByteBuffer.wrap(audioBuffer, 0, bytesRead));
463 |             	}
464 | 
465 | 				muxer.finish();
466 | 				
467 | 				fis.close();
468 | 				fos.close();
469 | 				
470 | 				
471 | 			} catch (Exception e) {
472 | 				Log.e(TAG, "IO", e);
473 | 			}
474 | 
475 | 		}
476 | 		
477 | 	
478 | 		
479 | 	}
480 | 	
481 | 	Handler h = new Handler ()
482 | 	{
483 | 
484 | 		@Override
485 | 		public void handleMessage(Message msg) {
486 | 			// TODO Auto-generated method stub
487 | 			super.handleMessage(msg);
488 | 			
489 | 			if (msg.what == 0)
490 | 			{
491 | 				int frames = msg.getData().getInt("frames");
492 | 				
493 | 					if (!mIsRecording)
494 | 						if (frames == 0)
495 | 							progress.setText("");
496 | 						else
497 | 							progress.setText("Processing: " + (mFramesTotal-frames) + '/' +  mFramesTotal);
498 | 					else
499 | 						progress.setText("Recording: " + mFramesTotal);
500 | 			}
501 | 			else if (msg.what == 1)
502 | 			{
503 | 				mIsRecording = false; //stop recording
504 | 				
505 | 				if (aac != null)
506 | 					aac.stopRecording();
507 | 				
508 | 			}
509 | 		}
510 | 		
511 | 	};
512 | 	
513 | 	 private void initAudio(final String audioPath) throws Exception {
514 | 
515 | 			fileAudio  = new File(audioPath); 
516 | 			
517 | 			   outputStreamAudio = new BufferedOutputStream(new info.guardianproject.iocipher.FileOutputStream(fileAudio),8192*8);
518 | 				
519 | 			   if (useAAC)
520 | 			   {
521 | 				   aac = new AACHelper();
522 | 				   aac.setEncoder(MediaConstants.sAudioSampleRate, MediaConstants.sAudioChannels, MediaConstants.sAudioBitRate);
523 | 			   }
524 | 			   else
525 | 			   {
526 | 			   
527 | 				   int minBufferSize = AudioRecord.getMinBufferSize(MediaConstants.sAudioSampleRate, 
528 | 					MediaConstants.sChannelConfigIn, 
529 | 				     AudioFormat.ENCODING_PCM_16BIT)*8;
530 | 				   
531 | 				   audioData = new byte[minBufferSize];
532 | 	
533 | 				   int audioSource = MediaRecorder.AudioSource.CAMCORDER;
534 | 				   
535 | 				   if (this.getCameraDirection() == CameraInfo.CAMERA_FACING_FRONT)
536 | 				   {
537 | 					   audioSource = MediaRecorder.AudioSource.MIC;
538 | 					   
539 | 				   }
540 | 				   
541 | 				   audioRecord = new AudioRecord(audioSource,
542 | 						   MediaConstants.sAudioSampleRate,
543 | 						   MediaConstants.sChannelConfigIn,
544 | 				     AudioFormat.ENCODING_PCM_16BIT,
545 | 				     minBufferSize);
546 | 			   }
547 | 	 }
548 | 	 
549 | 	 private void startAudioRecording ()
550 | 	 {
551 | 			  
552 | 		 
553 | 		 Thread thread = new Thread ()
554 | 		 {
555 | 			 
556 | 			 public void run ()
557 | 			 {
558 | 			 
559 | 				 if (useAAC)
560 | 				 {
561 | 					 try {
562 | 						aac.startRecording(outputStreamAudio);
563 | 					} catch (IOException e) {
564 | 						// TODO Auto-generated catch block
565 | 						e.printStackTrace();
566 | 					}
567 | 				 }
568 | 				 else
569 | 				 {
570 | 				   audioRecord.startRecording();
571 | 				   
572 | 				   while(mIsRecording){
573 | 				    int audioDataBytes = audioRecord.read(audioData, 0, audioData.length);
574 | 				    if (AudioRecord.ERROR_INVALID_OPERATION != audioDataBytes
575 | 		                    && outputStreamAudio != null) {
576 | 		                try {
577 | 		                	outputStreamAudio.write(audioData,0,audioDataBytes);
578 | 		                	
579 | 		                } catch (IOException e) {
580 | 		                    e.printStackTrace();
581 | 		                }
582 | 		            }
583 | 				   }
584 | 				   
585 | 				   audioRecord.stop();
586 | 				   try {
587 | 					   outputStreamAudio.flush();
588 | 					outputStreamAudio.close();
589 | 					} catch (IOException e) {
590 | 						// TODO Auto-generated catch block
591 | 						e.printStackTrace();
592 | 					}
593 | 				 }
594 | 				 
595 | 				 
596 | 			 }
597 | 		 };
598 | 		 
599 | 		 thread.start();
600 | 
601 | 	 }
602 | 	 
603 | 	  @Override
604 | 	   public void onConfigurationChanged(Configuration newConfig) {
605 | 		  
606 | 		  	mIsRecording = false;
607 | 		  	
608 | 	        super.onConfigurationChanged(newConfig);
609 | 
610 | 	   }
611 | 	 
612 | 	 
613 | 	
614 | }
615 | 


--------------------------------------------------------------------------------
/src/info/guardianproject/iocipher/camera/encoders/AACHelper.java:
--------------------------------------------------------------------------------
  1 | package info.guardianproject.iocipher.camera.encoders;
  2 | 
  3 | import java.io.IOException;
  4 | import java.io.InputStream;
  5 | import java.io.OutputStream;
  6 | import java.nio.ByteBuffer;
  7 | 
  8 | import android.annotation.TargetApi;
  9 | import android.media.AudioFormat;
 10 | import android.media.AudioManager;
 11 | import android.media.AudioRecord;
 12 | import android.media.AudioTrack;
 13 | import android.media.MediaCodec;
 14 | import android.media.MediaCodecInfo;
 15 | import android.media.MediaFormat;
 16 | import android.media.MediaRecorder.AudioSource;
 17 | import android.os.Build;
 18 | import android.util.Log;
 19 | /**
 20 |  * 
 21 |  * This file contains code from the IOCipher Camera Library "CipherCam".
 22 |  *
 23 |  * For more information about IOCipher, see https://guardianproject.info/code/iocipher
 24 |  * and this sample library: https://github.com/n8fr8/IOCipherCameraExample
 25 |  *
 26 |  * IOCipher Camera Sample is distributed under this license (aka the 3-clause BSD license)
 27 |  *
 28 |  * Some of this class was originally part of JCodec ( www.jcodec.org ) This software is distributed
 29 |  * under FreeBSD License
 30 |  * 
 31 |  * @author n8fr8, The JCodec project
 32 |  * 
 33 |  */
 34 | //from here: http://stackoverflow.com/questions/21804390/pcm-aac-encoder-pcmdecoder-in-real-time-with-correct-optimization
 35 | 
 36 | @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
 37 | public class AACHelper
 38 | {	
 39 | 
 40 |     private AudioRecord recorder;
 41 |     private AudioTrack player;
 42 | 
 43 |     private MediaCodec encoder;
 44 |     private MediaCodec decoder;
 45 | 
 46 |     private short audioFormat = AudioFormat.ENCODING_PCM_16BIT;
 47 |     private short channelConfig = AudioFormat.CHANNEL_IN_MONO;
 48 | 
 49 |     private int bufferSize;
 50 |     private boolean isRecording;
 51 |     private boolean isPlaying;
 52 | 
 53 |     public void startRecording (OutputStream outStream) throws IOException
 54 |     {
 55 |     		int read;
 56 |     		
 57 |             byte[] buffer1 = new byte[bufferSize];
 58 | 
 59 |             ByteBuffer[] inputBuffers;
 60 |             ByteBuffer[] outputBuffers;
 61 | 
 62 |             ByteBuffer inputBuffer;
 63 |             ByteBuffer outputBuffer;
 64 | 
 65 |             MediaCodec.BufferInfo bufferInfo;
 66 |             int inputBufferIndex;
 67 |             int outputBufferIndex;
 68 | 
 69 |             byte[] outData;
 70 | 
 71 |             encoder.start();
 72 |             recorder.startRecording();
 73 |             isRecording = true;
 74 |             
 75 |             while (isRecording)
 76 |             {
 77 |                 read = recorder.read(buffer1, 0, bufferSize);
 78 |                // Log.d("AudioRecoder", read + " bytes read");
 79 |                 //------------------------
 80 | 
 81 |                 inputBuffers = encoder.getInputBuffers();
 82 |                 outputBuffers = encoder.getOutputBuffers();
 83 |                 inputBufferIndex = encoder.dequeueInputBuffer(-1);
 84 |                 if (inputBufferIndex >= 0)
 85 |                 {
 86 |                     inputBuffer = inputBuffers[inputBufferIndex];
 87 |                     inputBuffer.clear();
 88 | 
 89 |                     inputBuffer.put(buffer1);
 90 | 
 91 |                     encoder.queueInputBuffer(inputBufferIndex, 0, buffer1.length, 0, 0);
 92 |                 }
 93 | 
 94 |                 bufferInfo = new MediaCodec.BufferInfo();
 95 |                 outputBufferIndex = encoder.dequeueOutputBuffer(bufferInfo, 0);
 96 | 
 97 |                 while (outputBufferIndex >= 0)
 98 |                 {
 99 |                     outputBuffer = outputBuffers[outputBufferIndex];
100 | 
101 |                     outputBuffer.position(bufferInfo.offset);
102 |                     outputBuffer.limit(bufferInfo.offset + bufferInfo.size);
103 | 
104 |                     outData = new byte[bufferInfo.size];
105 |                     outputBuffer.get(outData);
106 | 
107 |                     //TODO write out Data to stream?
108 |                     outStream.write(outData);
109 |                     
110 |                     encoder.releaseOutputBuffer(outputBufferIndex, false);
111 |                     outputBufferIndex = encoder.dequeueOutputBuffer(bufferInfo, 0);
112 | 
113 |                 }
114 |                 // ----------------------;
115 | 
116 |             }
117 |             encoder.stop();
118 |             recorder.stop();
119 |          
120 |         }
121 |     
122 |     public void stopRecording ()
123 |     {
124 |     	isRecording = false;
125 |     }
126 |        
127 | 
128 | 		public void startPlaying(InputStream is)
129 |         {
130 |             int len = 1024;
131 |             byte[] buffer2 = new byte[len];
132 | 
133 |             byte[] data = new byte[len];
134 | 
135 |             ByteBuffer[] inputBuffers;
136 |             ByteBuffer[] outputBuffers;
137 | 
138 |             ByteBuffer inputBuffer;
139 |             ByteBuffer outputBuffer;
140 | 
141 |             MediaCodec.BufferInfo bufferInfo;
142 |             int inputBufferIndex;
143 |             int outputBufferIndex;
144 |             byte[] outData;
145 |             try
146 |             {
147 |                 player.play();
148 |                 decoder.start();
149 |                 isPlaying = true;
150 |                 while (isPlaying)
151 |                 {
152 |                     
153 |                     	int read = is.read(data);
154 |                     	
155 |                         //===========
156 |                         inputBuffers = decoder.getInputBuffers();
157 |                         outputBuffers = decoder.getOutputBuffers();
158 |                         inputBufferIndex = decoder.dequeueInputBuffer(-1);
159 |                         if (inputBufferIndex >= 0)
160 |                         {
161 |                             inputBuffer = inputBuffers[inputBufferIndex];
162 |                             inputBuffer.clear();
163 | 
164 |                             inputBuffer.put(data);
165 | 
166 |                             decoder.queueInputBuffer(inputBufferIndex, 0, data.length, 0, 0);
167 |                         }
168 | 
169 |                         bufferInfo = new MediaCodec.BufferInfo();
170 |                         outputBufferIndex = decoder.dequeueOutputBuffer(bufferInfo, 0);
171 | 
172 |                         while (outputBufferIndex >= 0)
173 |                         {
174 |                             outputBuffer = outputBuffers[outputBufferIndex];
175 | 
176 |                             outputBuffer.position(bufferInfo.offset);
177 |                             outputBuffer.limit(bufferInfo.offset + bufferInfo.size);
178 | 
179 |                             outData = new byte[bufferInfo.size];
180 |                             outputBuffer.get(outData);
181 | 
182 |                           //  Log.d("AudioDecoder", outData.length + " bytes decoded");
183 | 
184 |                             player.write(outData, 0, outData.length);
185 | 
186 |                             decoder.releaseOutputBuffer(outputBufferIndex, false);
187 |                             outputBufferIndex = decoder.dequeueOutputBuffer(bufferInfo, 0);
188 | 
189 |                         }
190 | 
191 |                         //===========
192 | 
193 |                     
194 |                 }
195 | 
196 |                 decoder.stop();
197 |                 player.stop();
198 | 
199 |             }
200 |             catch (Exception e)
201 |             {
202 |             }
203 |         }
204 | 
205 | 
206 |     protected void onDestroy()
207 |     {
208 | 
209 |         recorder.release();
210 |         player.release();
211 |         encoder.release();
212 |         decoder.release();
213 | 
214 |     } 
215 |     
216 |     private int initAudioRecord(int rate)
217 |     {
218 |         try
219 |         {
220 |             Log.v("===========Attempting rate ", rate + "Hz, bits: " + audioFormat + ", channel: " + channelConfig);
221 |             bufferSize = AudioRecord.getMinBufferSize(rate, channelConfig, audioFormat);
222 | 
223 |             if (bufferSize != AudioRecord.ERROR_BAD_VALUE)
224 |             {
225 |                 // check if we can instantiate and have a success
226 |                 recorder = new AudioRecord(AudioSource.MIC, rate, channelConfig, audioFormat, bufferSize);
227 | 
228 |                 if (recorder.getState() == AudioRecord.STATE_INITIALIZED)
229 |                 {
230 |                     Log.v("===========final rate ", rate + "Hz, bits: " + audioFormat + ", channel: " + channelConfig);
231 | 
232 |                     return rate;
233 |                 }
234 |             }
235 |         }
236 |         catch (Exception e)
237 |         {
238 |             Log.v("error", "" + rate);
239 |         }
240 | 
241 |         return -1;
242 |     }
243 | 
244 |     public boolean setEncoder(int sampleRate, int channels, int bitRate) throws Exception
245 |     {
246 |         encoder = MediaCodec.createEncoderByType("audio/mp4a-latm");
247 |         MediaFormat format = new MediaFormat();
248 |         format.setString(MediaFormat.KEY_MIME, "audio/mp4a-latm");
249 |         format.setInteger(MediaFormat.KEY_CHANNEL_COUNT, channels);
250 |         format.setInteger(MediaFormat.KEY_SAMPLE_RATE, sampleRate);
251 |         format.setInteger(MediaFormat.KEY_BIT_RATE, bitRate * 1024);//AAC-HE 64kbps
252 |         format.setInteger(MediaFormat.KEY_AAC_PROFILE, MediaCodecInfo.CodecProfileLevel.AACObjectHE);
253 |         encoder.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
254 |         
255 |         initAudioRecord(sampleRate);
256 |         
257 |         return true;
258 |     }
259 | 
260 |     public boolean setDecoder(int sampleRate, int channels, int bitRate) throws Exception
261 |     {
262 |         decoder = MediaCodec.createDecoderByType("audio/mp4a-latm");
263 |         MediaFormat format = new MediaFormat();
264 |         format.setString(MediaFormat.KEY_MIME, "audio/mp4a-latm");
265 |         format.setInteger(MediaFormat.KEY_CHANNEL_COUNT, channels);
266 |         format.setInteger(MediaFormat.KEY_SAMPLE_RATE, sampleRate);
267 |         format.setInteger(MediaFormat.KEY_BIT_RATE, bitRate * 1024);//AAC-HE 64kbps
268 |         format.setInteger(MediaFormat.KEY_AAC_PROFILE, MediaCodecInfo.CodecProfileLevel.AACObjectHE);
269 | 
270 |         decoder.configure(format, null, null, 0);
271 |         
272 |         setPlayer(sampleRate);
273 | 
274 |         return true;
275 |     }
276 | 
277 |     public boolean setPlayer(int rate)
278 |     {
279 |         int bufferSizePlayer = AudioTrack.getMinBufferSize(rate, AudioFormat.CHANNEL_OUT_MONO, audioFormat);
280 |         Log.d("====buffer Size player ", String.valueOf(bufferSizePlayer));
281 | 
282 |         player= new AudioTrack(AudioManager.STREAM_MUSIC, rate, AudioFormat.CHANNEL_OUT_MONO, audioFormat, bufferSizePlayer, AudioTrack.MODE_STREAM);
283 | 
284 | 
285 |         if (player.getState() == AudioTrack.STATE_INITIALIZED)
286 |         {
287 | 
288 |             return true;
289 |         }
290 |         else
291 |         {
292 |             return false;
293 |         }
294 | 
295 |     }
296 | 
297 | 
298 | }


--------------------------------------------------------------------------------
/src/info/guardianproject/iocipher/camera/encoders/ImageToH264MP4Encoder.java:
--------------------------------------------------------------------------------
  1 | package info.guardianproject.iocipher.camera.encoders;
  2 | 
  3 | import java.io.IOException;
  4 | import java.nio.ByteBuffer;
  5 | import java.util.ArrayList;
  6 | 
  7 | import org.jcodec.codecs.h264.H264Encoder; 
  8 | 
  9 | import org.jcodec.codecs.h264.H264Utils;
 10 | import org.jcodec.common.AudioFormat;
 11 | import org.jcodec.common.NIOUtils;
 12 | import org.jcodec.common.SeekableByteChannel;
 13 | import org.jcodec.common.model.ColorSpace;
 14 | import org.jcodec.common.model.Picture;
 15 | import org.jcodec.containers.mp4.Brand;
 16 | import org.jcodec.containers.mp4.MP4Packet;
 17 | import org.jcodec.containers.mp4.TrackType;
 18 | import org.jcodec.containers.mp4.muxer.FramesMP4MuxerTrack;
 19 | import org.jcodec.containers.mp4.muxer.MP4Muxer;
 20 | import org.jcodec.containers.mp4.muxer.PCMMP4MuxerTrack;
 21 | import org.jcodec.scale.ColorUtil;
 22 | import org.jcodec.scale.Transform;
 23 | 
 24 | 
 25 | /**
 26 |  * 
 27 |  * This file contains code from the IOCipher Camera Library "CipherCam".
 28 |  *
 29 |  * For more information about IOCipher, see https://guardianproject.info/code/iocipher
 30 |  * and this sample library: https://github.com/n8fr8/IOCipherCameraExample
 31 |  *
 32 |  * IOCipher Camera Sample is distributed under this license (aka the 3-clause BSD license)
 33 |  *
 34 |  * Some of this class was originally part of JCodec ( www.jcodec.org ) This software is distributed
 35 |  * under FreeBSD License
 36 |  * 
 37 |  * @author n8fr8, The JCodec project
 38 |  * 
 39 |  */
 40 | public class ImageToH264MP4Encoder {
 41 |     private SeekableByteChannel ch;
 42 |     private Picture toEncode;
 43 |     private Transform transform;
 44 |     private H264Encoder encoder;
 45 |     private ArrayList<ByteBuffer> spsList;
 46 |     private ArrayList<ByteBuffer> ppsList;
 47 |     private FramesMP4MuxerTrack outTrack;
 48 |     private ByteBuffer _out;
 49 |     private int frameNo;
 50 |     private MP4Muxer muxer;
 51 | 
 52 |     private PCMMP4MuxerTrack audioTrack;
 53 |     private AudioFormat af;
 54 |     
 55 |     public ImageToH264MP4Encoder(SeekableByteChannel ch, AudioFormat af) throws IOException {
 56 |         this.ch = ch;
 57 |         this.af = af;
 58 |         // Muxer that will store the encoded frames
 59 |         muxer = new MP4Muxer(ch, Brand.MP4);
 60 | 
 61 |         // Add video track to muxer
 62 |         outTrack = muxer.addTrack(TrackType.VIDEO, 25);
 63 | 
 64 |         // Create an instance of encoder
 65 |         encoder = new H264Encoder();
 66 | 
 67 |         // Transform to convert between RGB and YUV
 68 |         transform = ColorUtil.getTransform(ColorSpace.RGB, encoder.getSupportedColorSpaces()[0]);
 69 | 
 70 |         // Encoder extra data ( SPS, PPS ) to be stored in a special place of
 71 |         // MP4
 72 |         spsList = new ArrayList<ByteBuffer>();
 73 |         ppsList = new ArrayList<ByteBuffer>();
 74 | 
 75 | 
 76 |         if (af != null)
 77 |         	audioTrack = muxer.addPCMAudioTrack(af);
 78 |     }
 79 | 
 80 |     public void addFrame(Picture pic) throws IOException {
 81 |         if (toEncode == null) {
 82 |             toEncode = Picture.create(pic.getWidth(), pic.getHeight(), encoder.getSupportedColorSpaces()[0]);
 83 |         }
 84 | 
 85 |         if (_out == null)
 86 |         {
 87 |             // Allocate a buffer big enough to hold output frames
 88 |             _out = ByteBuffer.allocate(pic.getWidth() * pic.getHeight() * 6);
 89 | 
 90 |         }
 91 |         
 92 |         // Perform conversion
 93 |         transform.transform(pic, toEncode);
 94 | 
 95 |         // Encode image into H.264 frame, the result is stored in '_out' buffer
 96 |         _out.clear();
 97 |         ByteBuffer result = encoder.encodeFrame(toEncode, _out);
 98 | 
 99 |         // Based on the frame above form correct MP4 packet
100 |         spsList.clear();
101 |         ppsList.clear();
102 |         H264Utils.wipePS(result, spsList, ppsList);
103 |         H264Utils.encodeMOVPacket(result);
104 | 
105 |         // Add packet to video track
106 |         outTrack.addFrame(new MP4Packet(result, frameNo, 25, 1, frameNo, true, null, frameNo, 0));
107 | 
108 |         frameNo++;
109 |     }
110 |     
111 |     public void addAudio (ByteBuffer buffer) throws IOException
112 |     {
113 |     	audioTrack.addSamples(buffer);
114 |     	
115 |     }
116 | 
117 |     public void finish() throws IOException {
118 |         // Push saved SPS/PPS to a special storage in MP4
119 |         outTrack.addSampleEntry(H264Utils.createMOVSampleEntry(spsList, ppsList, 4));
120 | 
121 |         audioTrack.addSampleEntry(MP4Muxer.audioSampleEntry(af));
122 | 
123 |         // Write MP4 header and finalize recording
124 |         muxer.writeHeader();
125 |         NIOUtils.closeQuietly(ch);
126 |     }
127 | }
128 | 


--------------------------------------------------------------------------------
/src/info/guardianproject/iocipher/camera/encoders/ImageToMJPEGMOVMuxer.java:
--------------------------------------------------------------------------------
  1 | package info.guardianproject.iocipher.camera.encoders;
  2 | 
  3 | import java.io.IOException;
  4 | import java.nio.ByteBuffer;
  5 | 
  6 | import org.jcodec.common.AudioFormat;
  7 | import org.jcodec.common.NIOUtils;
  8 | import org.jcodec.common.SeekableByteChannel;
  9 | import org.jcodec.common.model.Rational;
 10 | import org.jcodec.common.model.Size;
 11 | import org.jcodec.common.model.Unit;
 12 | import org.jcodec.containers.mp4.Brand;
 13 | import org.jcodec.containers.mp4.MP4Packet;
 14 | import org.jcodec.containers.mp4.TrackType;
 15 | import org.jcodec.containers.mp4.WebOptimizedMP4Muxer;
 16 | import org.jcodec.containers.mp4.muxer.FramesMP4MuxerTrack;
 17 | import org.jcodec.containers.mp4.muxer.MP4Muxer;
 18 | import org.jcodec.containers.mp4.muxer.PCMMP4MuxerTrack;
 19 | 
 20 | /**
 21 |  * 
 22 |  * This file contains code from the IOCipher Camera Library "CipherCam".
 23 |  *
 24 |  * For more information about IOCipher, see https://guardianproject.info/code/iocipher
 25 |  * and this sample library: https://github.com/n8fr8/IOCipherCameraExample
 26 |  *
 27 |  * IOCipher Camera Sample is distributed under this license (aka the 3-clause BSD license)
 28 |  *
 29 |  * Some of this class was originally part of JCodec ( www.jcodec.org ) This software is distributed
 30 |  * under FreeBSD License
 31 |  * 
 32 |  * @author n8fr8, The JCodec project
 33 |  * 
 34 |  */
 35 | public class ImageToMJPEGMOVMuxer {
 36 |     private SeekableByteChannel ch;
 37 |     
 38 |     private FramesMP4MuxerTrack videoTrack;
 39 |     private PCMMP4MuxerTrack audioTrack;
 40 |     
 41 |     private int frameNo = 0;
 42 |     private WebOptimizedMP4Muxer muxer;
 43 |     private Size size;
 44 |     
 45 |     private String imageType = "jpeg "; //or "png ";
 46 |     private AudioFormat af = null;
 47 |     
 48 |     private int framesPerSecond = -1;
 49 |     
 50 |     private final static String ENCODER_NAME = "JCODEC";
 51 |     
 52 |     public ImageToMJPEGMOVMuxer(SeekableByteChannel ch, AudioFormat af, int framesPerSecond) throws IOException {
 53 |         
 54 |     	this.ch = ch;
 55 |         this.af = af;
 56 |         this.framesPerSecond = framesPerSecond;
 57 |         
 58 |         // Muxer that will store the encoded frames
 59 |         muxer = new WebOptimizedMP4Muxer(ch, Brand.MOV, 16000);
 60 | 
 61 |         // Add video track to muxer
 62 |         videoTrack = muxer.addTrack(TrackType.VIDEO, framesPerSecond);
 63 |         muxer.addTimecodeTrack(framesPerSecond);
 64 |         videoTrack.setTgtChunkDuration(new Rational(2, 1), Unit.SEC);
 65 |         
 66 |        if (af != null)
 67 |         	audioTrack = muxer.addPCMAudioTrack(af);
 68 |        
 69 | 
 70 |     }
 71 | 
 72 |     public void addFrame(int width, int height, ByteBuffer buff, long timeScaleFPS, long duration) throws IOException {
 73 |         if (size == null) {
 74 |             size = new Size(width,height);            
 75 |             videoTrack.addSampleEntry(MP4Muxer.videoSampleEntry(imageType, size, ENCODER_NAME));
 76 |            
 77 |             if (af != null)
 78 |             	audioTrack.addSampleEntry(MP4Muxer.audioSampleEntry(af));	            
 79 |         }
 80 |         
 81 |         // Add packet to video track
 82 |      
 83 |         videoTrack.addFrame(new MP4Packet(buff, frameNo, timeScaleFPS, duration, frameNo, true, null, frameNo, 0));
 84 | 
 85 |         frameNo++;
 86 |     }
 87 |     
 88 |     public void addAudio (ByteBuffer buffer) throws IOException
 89 |     {
 90 |     	audioTrack.addSamples(buffer);
 91 |     }
 92 | 
 93 |     public void finish() throws IOException {
 94 |     	
 95 |     	  videoTrack.addSampleEntry(MP4Muxer.videoSampleEntry(imageType, size, ENCODER_NAME));
 96 |           
 97 |         // Write MP4 header and finalize recording  
 98 |     	  if (af != null)
 99 |     		  audioTrack.addSampleEntry(MP4Muxer.audioSampleEntry(af));
100 |     	  
101 |         muxer.writeHeader();
102 |         NIOUtils.closeQuietly(ch);
103 |     }
104 | }
105 | 


--------------------------------------------------------------------------------
/src/info/guardianproject/iocipher/camera/encoders/ImageToVP8Encoder.java:
--------------------------------------------------------------------------------
 1 | package info.guardianproject.iocipher.camera.encoders;
 2 | 
 3 | import java.io.IOException;
 4 | import java.nio.ByteBuffer;
 5 | 
 6 | import org.jcodec.codecs.vpx.VP8Encoder;
 7 | import org.jcodec.common.NIOUtils;
 8 | import org.jcodec.common.SeekableByteChannel;
 9 | import org.jcodec.common.model.ColorSpace;
10 | import org.jcodec.common.model.Picture;
11 | import org.jcodec.common.model.Size;
12 | import org.jcodec.containers.mkv.muxer.MKVMuxer;
13 | import org.jcodec.containers.mkv.muxer.MKVMuxerTrack;
14 | import org.jcodec.containers.mp4.muxer.MP4Muxer;
15 | import org.jcodec.scale.BitmapUtil;
16 | import org.jcodec.scale.RgbToYuv420p;
17 | 
18 | import android.graphics.Bitmap;
19 | 
20 | /**
21 |  * 
22 |  * This file contains code from the IOCipher Camera Library "CipherCam".
23 |  *
24 |  * For more information about IOCipher, see https://guardianproject.info/code/iocipher
25 |  * and this sample library: https://github.com/n8fr8/IOCipherCameraExample
26 |  *
27 |  * IOCipher Camera Sample is distributed under this license (aka the 3-clause BSD license)
28 |  *
29 |  * Some of this class was originally part of JCodec ( www.jcodec.org ) This software is distributed
30 |  * under FreeBSD License
31 |  * 
32 |  * @author n8fr8, The JCodec project
33 |  * 
34 |  */
35 | public class ImageToVP8Encoder {
36 |     private SeekableByteChannel ch;
37 |     private MKVMuxerTrack videoTrack;
38 |     private int frameNo = 0;
39 |     private MKVMuxer muxer;
40 |     private Size size;
41 |     
42 |     private VP8Encoder encoder;
43 |     private RgbToYuv420p transform;
44 |     
45 |     public ImageToVP8Encoder(SeekableByteChannel ch) throws IOException {
46 |         this.ch = ch;
47 |         // Muxer that will store the encoded frames
48 |         muxer = new MKVMuxer();
49 | 
50 |         encoder = new VP8Encoder(10);
51 |         transform = new RgbToYuv420p(0, 0);
52 |     }
53 | 
54 |     
55 |     public void addBitmap(int width, int height, Bitmap src, int frameIdx) throws IOException {
56 |         if (size == null) {
57 |             size = new Size(width,height);
58 |         }
59 |         
60 |         if (videoTrack == null) {
61 |             videoTrack = muxer.createVideoTrack(new Size(width, height), "V_MPEG4/ISO/AVC");
62 |         }
63 |         
64 |         // Add packet to video track
65 |         Picture yuv = Picture.create(width, height, ColorSpace.YUV420);
66 |         transform.transform(BitmapUtil.fromBitmap(src), yuv);        
67 |         ByteBuffer buf = ByteBuffer.allocate(width * height * 3);
68 |         ByteBuffer ff = encoder.encodeFrame(yuv, buf);
69 |         videoTrack.addSampleEntry(ff, frameIdx);
70 | 
71 |         frameNo++;
72 |     }
73 | 
74 |     public void finish() throws IOException {
75 |      
76 |     	muxer.mux(ch);
77 |         NIOUtils.closeQuietly(ch);
78 |     }
79 | }
80 | 


--------------------------------------------------------------------------------
/src/info/guardianproject/iocipher/camera/encoders/YUVtoWebmMuxer.java:
--------------------------------------------------------------------------------
 1 | package info.guardianproject.iocipher.camera.encoders;
 2 | 
 3 | import java.io.IOException;
 4 | import java.nio.ByteBuffer;
 5 | 
 6 | import org.jcodec.codecs.vpx.IVFMuxer;
 7 | import org.jcodec.codecs.vpx.VP8Encoder;
 8 | import org.jcodec.common.NIOUtils;
 9 | import org.jcodec.common.SeekableByteChannel;
10 | import org.jcodec.common.model.ColorSpace;
11 | import org.jcodec.common.model.Packet;
12 | import org.jcodec.common.model.Picture;
13 | import org.jcodec.containers.mkv.muxer.MKVMuxerTrack;
14 | 
15 | /**
16 |  * 
17 |  * This file contains code from the IOCipher Camera Library "CipherCam".
18 |  *
19 |  * For more information about IOCipher, see https://guardianproject.info/code/iocipher
20 |  * and this sample library: https://github.com/n8fr8/IOCipherCameraExample
21 |  *
22 |  * IOCipher Camera Sample is distributed under this license (aka the 3-clause BSD license)
23 |  *
24 |  * Some of this class was originally part of JCodec ( www.jcodec.org ) This software is distributed
25 |  * under FreeBSD License
26 |  * 
27 |  * @author n8fr8, The JCodec project
28 |  * 
29 |  */
30 | public class YUVtoWebmMuxer {
31 |     private SeekableByteChannel ch;
32 |     private VP8Encoder encoder;    
33 |     private MKVMuxerTrack videoTrack;
34 |     private IVFMuxer muxer;
35 |     
36 |     public YUVtoWebmMuxer(SeekableByteChannel ch, int width, int height) throws IOException {
37 |     
38 |         this.ch = ch;
39 |         
40 |         muxer = new IVFMuxer(ch,width,height,25);
41 | 
42 |         // Create an instance of encoder
43 |         encoder = new VP8Encoder(10);
44 | 
45 | 
46 |     }
47 | 
48 |     public void encodeNativeFrame(ByteBuffer data, int width, int height, int frameIdx) throws IOException {
49 |     	
50 |         Picture yuv = Picture.create(width, height, ColorSpace.YUV420);    
51 |         
52 |         ByteBuffer ff = encoder.encodeFrame(yuv, data);
53 |         Packet packet = new Packet(ff, frameIdx, 1, 1, frameIdx, true, null);
54 |         muxer.addFrame(packet);
55 | 
56 | 
57 |     }
58 | 
59 |     public void finish() throws IOException {
60 | 
61 |         NIOUtils.closeQuietly(ch);
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/src/info/guardianproject/iocipher/camera/io/IOCipherContentProvider.java:
--------------------------------------------------------------------------------
  1 | package info.guardianproject.iocipher.camera.io;
  2 | /**
  3 |  * 
  4 |  * This file contains code from the IOCipher Camera Library "CipherCam".
  5 |  *
  6 |  * For more information about IOCipher, see https://guardianproject.info/code/iocipher
  7 |  * and this sample library: https://github.com/n8fr8/IOCipherCameraExample
  8 |  *
  9 |  * IOCipher Camera Sample is distributed under this license (aka the 3-clause BSD license)
 10 |  *
 11 |  * Some of this class was originally part of JCodec ( www.jcodec.org ) This software is distributed
 12 |  * under FreeBSD License
 13 |  * 
 14 |  * @author n8fr8, The JCodec project
 15 |  * 
 16 |  */
 17 | // inspired by https://github.com/commonsguy/cw-omnibus/tree/master/ContentProvider/Pipe
 18 | 
 19 | import info.guardianproject.iocipher.File;
 20 | import info.guardianproject.iocipher.FileInputStream;
 21 | 
 22 | import java.io.BufferedOutputStream;
 23 | import java.io.FileNotFoundException;
 24 | import java.io.IOException;
 25 | import java.io.InputStream;
 26 | import java.io.OutputStream;
 27 | import java.util.HashMap;
 28 | import java.util.UUID;
 29 | 
 30 | import android.content.ContentProvider;
 31 | import android.content.ContentValues;
 32 | import android.database.Cursor;
 33 | import android.net.Uri;
 34 | import android.os.ParcelFileDescriptor;
 35 | import android.os.ParcelFileDescriptor.AutoCloseOutputStream;
 36 | import android.util.Log;
 37 | import android.webkit.MimeTypeMap;
 38 | 
 39 | public class IOCipherContentProvider extends ContentProvider {
 40 | 	public static final String TAG = "IOCipherContentProvider";
 41 | 	public static final String DEFAULT_AUTHORITY = "info.guardianproject.iocipher.camera";
 42 | 	private MimeTypeMap mimeTypeMap;
 43 | 
 44 | 	
 45 | 	private static HashMap<String,String> keyToPathMap = new HashMap<String,String>();
 46 | 	
 47 | 	@Override
 48 | 	public boolean onCreate() {
 49 | 		mimeTypeMap = MimeTypeMap.getSingleton();
 50 | 		return true;
 51 | 	}
 52 | 	
 53 | 	/*
 54 | 	 * Before something can be accessed by the content provider, it must be added to this map.
 55 | 	 * This protects from any app being able to query the IOCipher store at will
 56 | 	 */
 57 | 	public static String addShare (String path, String authority)
 58 | 	{
 59 | 		String uuid = UUID.randomUUID().toString().substring(0,8) + '-' + new File(path).getName();
 60 | 		keyToPathMap.put(uuid, path);
 61 | 		return "content://" + authority + '/' + uuid;
 62 | 	}
 63 | 
 64 | 	@Override
 65 | 	public String getType(Uri uri) {
 66 | 		String fileExtension = MimeTypeMap.getFileExtensionFromUrl(uri.toString());
 67 | 		String type = mimeTypeMap.getMimeTypeFromExtension(fileExtension);
 68 | 		return type;
 69 | 	}
 70 | 
 71 | 	@Override
 72 | 	public ParcelFileDescriptor openFile(Uri uri, String mode)
 73 | 			throws FileNotFoundException {
 74 | 		ParcelFileDescriptor[] pipe = null;
 75 | 		InputStream in = null;
 76 | 
 77 | 		String pathKey = uri.getPath();
 78 | 		if (pathKey.startsWith("/"));
 79 | 			pathKey = pathKey.substring(1);
 80 | 			
 81 | 		String pathReal = keyToPathMap.get(pathKey);
 82 | 		
 83 | 		try {
 84 | 			File fileShare = new File(pathReal);
 85 | 	
 86 | 			pipe = ParcelFileDescriptor.createPipe();			
 87 | 			in = new FileInputStream(fileShare);
 88 | 			new PipeFeederThread(in,
 89 | 					new AutoCloseOutputStream(pipe[1])
 90 | 				{
 91 | 				
 92 | 				}		
 93 | 					).start();
 94 | 			
 95 | 			
 96 | 		} catch (IOException e) {
 97 | 			Log.e(TAG, "Error opening pipe", e);
 98 | 			throw new FileNotFoundException("Could not open pipe for: "
 99 | 					+ uri.toString());
100 | 		}		
101 | 		return (pipe[0]);
102 | 	}
103 | 
104 | 	@Override
105 | 	public Cursor query(Uri url, String[] projection, String selection,
106 | 			String[] selectionArgs, String sort) {
107 | 		
108 | 		//Log.d(TAG,"query called: " + url.toString());
109 | 		
110 | 		//throw new RuntimeException("Operation not supported");
111 | 		return null;
112 | 	}
113 | 
114 | 	@Override
115 | 	public Uri insert(Uri uri, ContentValues initialValues) {
116 | 		throw new RuntimeException("Operation not supported");
117 | 	}
118 | 
119 | 	@Override
120 | 	public int update(Uri uri, ContentValues values, String where,
121 | 			String[] whereArgs) {
122 | 		throw new RuntimeException("Operation not supported");
123 | 	}
124 | 
125 | 	@Override
126 | 	public int delete(Uri uri, String where, String[] whereArgs) {
127 | 		throw new RuntimeException("Operation not supported");
128 | 	}
129 | 
130 | 	static class PipeFeederThread extends Thread {
131 | 		InputStream in;
132 | 		BufferedOutputStream out;
133 | 
134 | 		PipeFeederThread(InputStream in, OutputStream out) {
135 | 			this.in = in;
136 | 			this.out = new BufferedOutputStream(out, 32000);	
137 | 			setDaemon(true);
138 | 		}
139 | 
140 | 		@Override
141 | 		public void run() {
142 | 			
143 | 			byte[] buf = new byte[4096];
144 | 			int len;
145 | 
146 | 			try {
147 | 				
148 | 				int idx = 0;
149 | 				
150 | 				while ((len = in.read(buf)) != -1)
151 | 				{
152 | 					out.write(buf, 0, len);
153 | 					idx+=buf.length;
154 | 				//	Log.d(TAG,"writing video at " + idx);
155 | 				}
156 | 				
157 | 				in.close();
158 | 				out.flush();
159 | 				out.close();
160 | 				
161 | 			} catch (IOException e) {
162 | 				Log.e(TAG, "File transfer failed:", e);
163 | 			}
164 | 		}
165 | 	}
166 | }
167 | 


--------------------------------------------------------------------------------
/src/info/guardianproject/iocipher/camera/io/IOCipherFileChannelWrapper.java:
--------------------------------------------------------------------------------
 1 | package info.guardianproject.iocipher.camera.io;
 2 | 
 3 | 
 4 | import info.guardianproject.iocipher.IOCipherFileChannel;
 5 | 
 6 | 
 7 | import java.io.FileNotFoundException;
 8 | import java.io.IOException;
 9 | import java.nio.ByteBuffer;
10 | 
11 | import org.jcodec.common.SeekableByteChannel;
12 | 
13 | import android.util.Log;
14 | /**
15 |  * 
16 |  * This file contains code from the IOCipher Camera Library "CipherCam".
17 |  *
18 |  * For more information about IOCipher, see https://guardianproject.info/code/iocipher
19 |  * and this sample library: https://github.com/n8fr8/IOCipherCameraExample
20 |  *
21 |  * IOCipher Camera Sample is distributed under this license (aka the 3-clause BSD license)
22 |  *
23 |  * Some of this class was originally part of JCodec ( www.jcodec.org ) This software is distributed
24 |  * under FreeBSD License
25 |  * 
26 |  * @author n8fr8, The JCodec project
27 |  * 
28 |  */
29 | public class IOCipherFileChannelWrapper implements SeekableByteChannel {
30 | 
31 |     private IOCipherFileChannel ch;
32 |     private final static String TAG = "IOCipherFileChannelWrapper";
33 |     
34 |     public IOCipherFileChannelWrapper(IOCipherFileChannel ch) throws FileNotFoundException {
35 |         this.ch = ch;
36 |     }
37 | 
38 |     @Override
39 |     public int read(ByteBuffer arg0) throws IOException {
40 | 
41 |         return ch.read(arg0);
42 |     }
43 | 
44 |     @Override
45 |     public void close() throws IOException {
46 |         ch.close();
47 |     }
48 | 
49 |     @Override
50 |     public boolean isOpen() {
51 |         return ch.isOpen();
52 |     }
53 | 
54 |     @Override
55 |     public synchronized int write(ByteBuffer arg0) throws IOException {
56 |     	int size = arg0.remaining();
57 |     	long newPos = position() + size;
58 |         int result = ch.write(arg0, position());
59 |         position(newPos);
60 |         return result;
61 |     }
62 | 
63 |     @Override
64 |     public long position() throws IOException {
65 |         return ch.position();
66 |     }
67 | 
68 |     @Override
69 |     public SeekableByteChannel position(long newPosition) throws IOException {
70 |         
71 |         ch.position(newPosition);
72 |         
73 |         return this;
74 |     }
75 | 
76 |     @Override
77 |     public long size() throws IOException {
78 |         return ch.size();
79 |     }
80 | 
81 |     @Override
82 |     public SeekableByteChannel truncate(long size) throws IOException {
83 |         ch.truncate(size);
84 |         return this;
85 |     }
86 | }


--------------------------------------------------------------------------------
/src/info/guardianproject/iocipher/camera/viewer/ImageViewerActivity.java:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * 
  3 |  * This file contains code from the IOCipher Camera Library "CipherCam".
  4 |  *
  5 |  * For more information about IOCipher, see https://guardianproject.info/code/iocipher
  6 |  * and this sample library: https://github.com/n8fr8/IOCipherCameraExample
  7 |  *
  8 |  * IOCipher Camera Sample is distributed under this license (aka the 3-clause BSD license)
  9 |  *
 10 |  * Some of this class was originally part of JCodec ( www.jcodec.org ) This software is distributed
 11 |  * under FreeBSD License
 12 |  * 
 13 |  * @author n8fr8, The JCodec project
 14 |  * 
 15 |  */
 16 | package info.guardianproject.iocipher.camera.viewer;
 17 | 
 18 | import info.guardianproject.iocipher.File;
 19 | import info.guardianproject.iocipher.FileInputStream;
 20 | import info.guardianproject.iocipher.camera.R;
 21 | import android.app.Activity;
 22 | import android.content.Intent;
 23 | import android.graphics.Bitmap;
 24 | import android.graphics.BitmapFactory;
 25 | import android.os.Bundle;
 26 | import android.util.Log;
 27 | import android.view.Menu;
 28 | import android.view.MenuItem;
 29 | import android.view.View;
 30 | import android.view.Window;
 31 | import android.view.WindowManager;
 32 | import android.widget.ImageView;
 33 | 
 34 | public class ImageViewerActivity extends Activity {
 35 | 
 36 | 
 37 | 	/** Called when the activity is first created. */
 38 | 
 39 | 	@Override
 40 | 	public void onCreate(Bundle savedInstanceState) {
 41 | 		super.onCreate(savedInstanceState);
 42 | 
 43 | 		requestWindowFeature(Window.FEATURE_NO_TITLE);
 44 | 	    getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, 
 45 | 	    WindowManager.LayoutParams.FLAG_FULLSCREEN);
 46 | 
 47 | 		//prevent screenshots
 48 | 		getWindow().setFlags(WindowManager.LayoutParams.FLAG_SECURE,
 49 | 				WindowManager.LayoutParams.FLAG_SECURE);
 50 | 		
 51 | 		// This example uses decor view, but you can use any visible view.
 52 | 		View decorView = getWindow().getDecorView();
 53 | 		int uiOptions = View.SYSTEM_UI_FLAG_LOW_PROFILE;
 54 | 		decorView.setSystemUiVisibility(uiOptions);
 55 | 		
 56 | 	        
 57 | 		setContentView(R.layout.pzsimageview);
 58 | 		
 59 | 		Intent intent = getIntent();
 60 | 		String action = intent.getAction();
 61 | 		String type = intent.getType();
 62 | 		
 63 | 		ImageView iv = (ImageView)findViewById(R.id.imageview);
 64 | 		
 65 | 		if (intent.hasExtra("vfs"))
 66 | 		{
 67 | 			try
 68 | 			{
 69 | 				File file = new File(intent.getExtras().getString("vfs"));
 70 | 				Bitmap bmp = null;
 71 | 				
 72 | 				BitmapFactory.Options options = new BitmapFactory.Options();
 73 | 				options.inJustDecodeBounds = true;
 74 | 				 BitmapFactory.decodeStream(new FileInputStream(file),null,options);
 75 | 				int imageHeight = options.outHeight;
 76 | 				int imageWidth = options.outWidth;
 77 | 				String imageType = options.outMimeType;
 78 | 				
 79 | 				options.inJustDecodeBounds = false;
 80 | 				options.inSampleSize = 2;
 81 | 				bmp =  BitmapFactory.decodeStream(new FileInputStream(file),null,options);
 82 | 				
 83 | 				iv.setImageBitmap(bmp);
 84 | 			}
 85 | 			catch (Exception e)
 86 | 			{
 87 | 				Log.d("Image","error showing vfs image",e);
 88 | 			}
 89 | 		}
 90 | 		else
 91 | 		{
 92 | 			iv.setImageURI(intent.getData());
 93 | 		}
 94 | 		
 95 | 	}
 96 | 
 97 | 	protected void onResume() {
 98 | 		super.onResume();
 99 | 		
100 | 	}
101 | 
102 | 	protected void onDestroy() {
103 | 		super.onDestroy();
104 | 		
105 | 	}
106 | 	
107 | 	@Override
108 |     public boolean onCreateOptionsMenu(Menu menu) {
109 |         
110 |       //  MenuInflater inflater = getMenuInflater();
111 |        // inflater.inflate(R.menu.main, menu);
112 |         
113 |         return true;
114 | 	}
115 | 	
116 | 
117 |     @Override
118 |     public boolean onOptionsItemSelected(MenuItem item) {
119 |     	/**
120 |         switch (item.getItemId()) {
121 | 
122 |         case R.id.menu_camera:
123 |         	
124 |         	Intent intent = new Intent(this,SecureSelfieActivity.class);
125 |         	intent.putExtra("basepath", "/");
126 |         	startActivityForResult(intent, 1);
127 |         	
128 |         	return true;
129 |         case R.id.menu_video:
130 |         	
131 |         	intent = new Intent(this,VideoRecorderActivity.class);
132 |         	intent.putExtra("basepath", "/");
133 |         	startActivityForResult(intent, 1);
134 |         	
135 |         	return true;	
136 |         }	*/
137 |         
138 |         return false;
139 |     }
140 | 
141 | 	
142 | 	
143 | 		
144 | 	
145 | 		
146 | 		
147 | }
148 | 


--------------------------------------------------------------------------------
/src/info/guardianproject/iocipher/camera/viewer/MjpegInputStream.java:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * 
  3 |  * This file contains code from the IOCipher Camera Library "CipherCam".
  4 |  *
  5 |  * For more information about IOCipher, see https://guardianproject.info/code/iocipher
  6 |  * and this sample library: https://github.com/n8fr8/IOCipherCameraExample
  7 |  *
  8 |  * IOCipher Camera Sample is distributed under this license (aka the 3-clause BSD license)
  9 |  *
 10 |  * Some of this class was originally part of JCodec ( www.jcodec.org ) This software is distributed
 11 |  * under FreeBSD License
 12 |  * 
 13 |  * @author n8fr8, The JCodec project
 14 |  * 
 15 |  */
 16 | package info.guardianproject.iocipher.camera.viewer;
 17 | 
 18 | import java.io.BufferedInputStream;
 19 | import java.io.ByteArrayInputStream;
 20 | import java.io.DataInputStream;
 21 | import java.io.EOFException;
 22 | import java.io.IOException;
 23 | import java.io.InputStream;
 24 | import java.util.Properties;
 25 | 
 26 | import android.graphics.Bitmap;
 27 | import android.graphics.BitmapFactory;
 28 | import android.util.Log;
 29 | 
 30 | public class MjpegInputStream extends DataInputStream {
 31 |     private static final String TAG = "MjpegInputStream";
 32 | 
 33 |     private final byte[] SOI_MARKER = { (byte) 0xFF, (byte) 0xD8 };
 34 |     private final byte[] EOF_MARKER = { (byte) 0xFF, (byte) 0xD9 };
 35 |     private final String CONTENT_LENGTH = "Content-Length";
 36 |     private final static int HEADER_MAX_LENGTH = 2048*4;
 37 |     private final static int FRAME_MAX_LENGTH = 1000000 + HEADER_MAX_LENGTH;
 38 |     private int mContentLength = -1;
 39 | 
 40 |     public MjpegInputStream(InputStream in) {
 41 |         super(new BufferedInputStream(in, FRAME_MAX_LENGTH));
 42 |     }
 43 | 
 44 |     private int getEndOfSeqeunce(DataInputStream in, byte[] sequence) throws IOException {
 45 |     	
 46 |         int seqIndex = 0;
 47 |         byte c;
 48 |         int i = 0;
 49 |         while(true) {
 50 |         	try
 51 |         	{
 52 | 	            c = (byte) in.readUnsignedByte();
 53 | 	            if(c == sequence[seqIndex]) {
 54 | 	                seqIndex++;
 55 | 	                if(seqIndex == sequence.length) {
 56 | 	                    return i + 1;
 57 | 	                }
 58 | 	            } else {
 59 | 	                seqIndex = 0;
 60 | 	            }
 61 | 	            i++;
 62 |         	}
 63 |         	catch (EOFException ef)
 64 |         	{
 65 |         		Log.e(TAG,"EOF Exception at idx:" + i);
 66 |         		break;
 67 |         	}
 68 |         }
 69 |         return -1;
 70 |     }
 71 | 
 72 |     private int getStartOfSequence(DataInputStream in, byte[] sequence) throws IOException {
 73 |         int end = getEndOfSeqeunce(in, sequence);
 74 |         return (end < 0) ? (-1) : (end - sequence.length);
 75 |     }
 76 | 
 77 |     private int parseContentLength(byte[] headerBytes) throws IOException, NumberFormatException {
 78 |         ByteArrayInputStream headerIn = new ByteArrayInputStream(headerBytes);
 79 |         Properties props = new Properties();
 80 |         props.load(headerIn);
 81 |         return Integer.parseInt(props.getProperty(CONTENT_LENGTH));
 82 |     }   
 83 | 
 84 |     public Bitmap readMjpegFrame() throws IOException {
 85 |     	
 86 |     	//if (in.available() < FRAME_MAX_LENGTH)
 87 |     		//return null;
 88 |     	
 89 |         mark(FRAME_MAX_LENGTH);
 90 |         int headerLen = getStartOfSequence(this, SOI_MARKER);
 91 |         
 92 |         if (headerLen < 0)
 93 |         	return null;
 94 |         
 95 |         reset();
 96 |         byte[] header = new byte[headerLen];
 97 |    //     Log.d(TAG,"frame header: " + new String(header));
 98 |         readFully(header);
 99 |         mContentLength = getEndOfSeqeunce(this, EOF_MARKER); 
100 |         
101 |         if (mContentLength < 0)
102 |         	return null;
103 |         
104 |         /*
105 |         try {
106 |             mContentLength = parseContentLength(header);
107 |         } catch (NumberFormatException nfe) {             
108 |         	Log.d(TAG, "catch NumberFormatException hit", nfe);
109 |             mContentLength = getEndOfSeqeunce(this, EOF_MARKER); 
110 |         }*/
111 |         reset();
112 |         byte[] frameData = new byte[mContentLength];
113 |         skipBytes(headerLen);
114 |         readFully(frameData);
115 |         
116 |         return BitmapFactory.decodeStream(new ByteArrayInputStream(frameData));
117 |     }
118 | }


--------------------------------------------------------------------------------
/src/info/guardianproject/iocipher/camera/viewer/MjpegView.java:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * 
  3 |  * This file contains code from the IOCipher Camera Library "CipherCam".
  4 |  *
  5 |  * For more information about IOCipher, see https://guardianproject.info/code/iocipher
  6 |  * and this sample library: https://github.com/n8fr8/IOCipherCameraExample
  7 |  *
  8 |  * IOCipher Camera Sample is distributed under this license (aka the 3-clause BSD license)
  9 |  *
 10 |  * @author n8fr8
 11 |  * 
 12 |  */
 13 | package info.guardianproject.iocipher.camera.viewer;
 14 | 
 15 | 
 16 | import android.content.Context;
 17 | import android.graphics.Bitmap;
 18 | import android.graphics.Canvas;
 19 | import android.graphics.Color;
 20 | import android.graphics.Paint;
 21 | import android.graphics.PorterDuff;
 22 | import android.graphics.PorterDuffXfermode;
 23 | import android.graphics.Rect;
 24 | import android.graphics.Typeface;
 25 | import android.util.AttributeSet;
 26 | import android.util.Log;
 27 | import android.view.SurfaceHolder;
 28 | import android.view.SurfaceView;
 29 | 
 30 | public class MjpegView extends SurfaceView implements SurfaceHolder.Callback {
 31 |     private static final String TAG = "MjpegView";
 32 | 
 33 |     public final static int POSITION_UPPER_LEFT  = 9;
 34 |     public final static int POSITION_UPPER_RIGHT = 3;
 35 |     public final static int POSITION_LOWER_LEFT  = 12;
 36 |     public final static int POSITION_LOWER_RIGHT = 6;
 37 | 
 38 |     public final static int SIZE_STANDARD   = 1; 
 39 |     public final static int SIZE_BEST_FIT   = 4;
 40 |     public final static int SIZE_FULLSCREEN = 8;
 41 | 
 42 |     private MjpegViewThread thread;
 43 |     private MjpegInputStream mIn = null;    
 44 |     private boolean showFps = false;
 45 |     private boolean mRun = false;
 46 |     private boolean surfaceDone = false;    
 47 |     private Paint overlayPaint;
 48 |     private int overlayTextColor;
 49 |     private int overlayBackgroundColor;
 50 |     private int ovlPos;
 51 |     private int dispWidth;
 52 |     private int dispHeight;
 53 |     private int displayMode;
 54 |     private Context context;
 55 |     private SurfaceHolder holder;
 56 |     private int frameDelay = 0;
 57 | 
 58 |     private int lastW = -1, lastH = -1;
 59 |     
 60 | 	public class MjpegViewThread extends Thread {
 61 | 		
 62 |         private SurfaceHolder mSurfaceHolder;
 63 |         private int frameCounter = 0;
 64 |         private long start;
 65 |         private Bitmap ovl;
 66 |         
 67 |         public MjpegViewThread(SurfaceHolder surfaceHolder, Context context) {
 68 |             mSurfaceHolder = surfaceHolder;
 69 |             
 70 |         }
 71 | 
 72 |         private Rect destRect(int bmw, int bmh) {
 73 |             int tempx;
 74 |             int tempy;
 75 |             if (displayMode == MjpegView.SIZE_STANDARD) {
 76 |                 tempx = (dispWidth / 2) - (bmw / 2);
 77 |                 tempy = (dispHeight / 2) - (bmh / 2);
 78 |                 return new Rect(tempx, tempy, bmw + tempx, bmh + tempy);
 79 |             }
 80 |             if (displayMode == MjpegView.SIZE_BEST_FIT) {
 81 |                 float bmasp = (float) bmw / (float) bmh;
 82 |                 bmw = dispWidth;
 83 |                 bmh = (int) (dispWidth / bmasp);
 84 |                 if (bmh > dispHeight) {
 85 |                     bmh = dispHeight;
 86 |                     bmw = (int) (dispHeight * bmasp);
 87 |                 }
 88 |                 tempx = (dispWidth / 2) - (bmw / 2);
 89 |                 tempy = (dispHeight / 2) - (bmh / 2);
 90 |                 return new Rect(tempx, tempy, bmw + tempx, bmh + tempy);
 91 |             }
 92 |             if (displayMode == MjpegView.SIZE_FULLSCREEN){
 93 |                 return new Rect(0, 0, dispWidth, dispHeight);
 94 |             }
 95 |             return null;
 96 |         }
 97 | 
 98 |         public void setSurfaceSize(int width, int height) {
 99 |             synchronized(mSurfaceHolder) {
100 |                 dispWidth = width;
101 |                 dispHeight = height;
102 |             }
103 |         }
104 | 
105 |         private Bitmap makeFpsOverlay(Paint p, String text) {
106 |             Rect b = new Rect();
107 |             p.getTextBounds(text, 0, text.length(), b);
108 |             int bwidth  = b.width()+2;
109 |             int bheight = b.height()+2;
110 |             Bitmap bm = Bitmap.createBitmap(bwidth, bheight, Bitmap.Config.ARGB_8888);
111 |             Canvas c = new Canvas(bm);
112 |             p.setColor(overlayBackgroundColor);
113 |             c.drawRect(0, 0, bwidth, bheight, p);
114 |             p.setColor(overlayTextColor);
115 |             c.drawText(text, -b.left+1, (bheight/2)-((p.ascent()+p.descent())/2)+1, p);
116 |             return bm;           
117 |         }
118 | 
119 |         public void run() {
120 |             start = System.currentTimeMillis();
121 |             PorterDuffXfermode mode = new PorterDuffXfermode(PorterDuff.Mode.DST_OVER);
122 |             Bitmap bm;
123 |             int width;
124 |             int height;
125 |             Rect destRect;
126 |             Canvas c = null;
127 |             Paint p = new Paint();
128 | 
129 |             while (mRun) {
130 |                 if(surfaceDone) {
131 |                     try {
132 |                         c = mSurfaceHolder.lockCanvas();
133 |                         
134 |                         if (c == null)
135 |                         	break;
136 |                         
137 |                         synchronized (mSurfaceHolder) {
138 |                             try {
139 |                                 bm = mIn.readMjpegFrame();
140 |                                 
141 |                                 if (bm == null)
142 |                                 {
143 |                                 	mRun = false;
144 |                                 	break;
145 |                                 }
146 |                                 
147 |                                 destRect = destRect(bm.getWidth(),bm.getHeight());
148 |                                 c.drawColor(Color.BLACK);
149 |                                 c.drawBitmap(bm, null, destRect, p);
150 |                                 if(showFps) {
151 |                                     p.setXfermode(mode);
152 |                                     if(ovl != null) {
153 |                                         height = ((ovlPos & 1) == 1) ? destRect.top : destRect.bottom-ovl.getHeight();
154 |                                         width  = ((ovlPos & 8) == 8) ? destRect.left : destRect.right -ovl.getWidth();
155 |                                         c.drawBitmap(ovl, width, height, null);
156 |                                     }
157 |                                     p.setXfermode(null);
158 |                                     frameCounter++;
159 |                                     
160 |                                 }
161 |                                 
162 |                                 if (frameDelay > 0)
163 |                                 	Thread.sleep(frameDelay);
164 |                                 
165 |                                 
166 |                             } catch (Exception e) {
167 |                                 Log.e(TAG, "catch IOException hit in run", e);
168 |                             }
169 |                         }
170 |                     } finally { 
171 |                         if (c != null) {
172 |                             mSurfaceHolder.unlockCanvasAndPost(c); 
173 |                         }
174 |                     }
175 |                 }
176 |             }
177 |         }
178 |     }
179 | 
180 |     private void init(Context context) {
181 |     	this.context = context;
182 |         holder = getHolder();
183 |         holder.addCallback(this);
184 |         setFocusable(true);
185 |         overlayPaint = new Paint();
186 |         overlayPaint.setTextAlign(Paint.Align.LEFT);
187 |         overlayPaint.setTextSize(12);
188 |         overlayPaint.setTypeface(Typeface.DEFAULT);
189 |         overlayTextColor = Color.WHITE;
190 |         overlayBackgroundColor = Color.BLACK;
191 |         ovlPos = MjpegView.POSITION_LOWER_RIGHT;
192 |         displayMode = MjpegView.SIZE_STANDARD;
193 |         dispWidth = getWidth();
194 |         dispHeight = getHeight();
195 |     }
196 | 
197 |     public void startPlayback() { 
198 |         if(mIn != null) {
199 |             mRun = true;          
200 |             thread = new MjpegViewThread(holder, context);
201 |             if (lastW != -1)
202 |             {
203 |             	thread.setSurfaceSize(lastW, lastH);
204 |             }
205 |             
206 |             thread.start();         
207 |         }
208 |     }
209 | 
210 |     public boolean isPlaying ()
211 |     {
212 |     	return mRun;
213 |     }
214 |     
215 |     public void stopPlayback() { 
216 |         mRun = false;
217 |         boolean retry = true;
218 |         while(retry) {
219 |             try {
220 |                 thread.join();
221 |                 retry = false;
222 |             } catch (InterruptedException e) {
223 |                 e.getStackTrace();
224 |                 Log.d(TAG, "catch IOException hit in stopPlayback", e);
225 |             }
226 |         }
227 |     }
228 | 
229 |     public MjpegView(Context context, AttributeSet attrs) { 
230 |         super(context, attrs); init(context); 
231 |     }
232 | 
233 |     public void surfaceChanged(SurfaceHolder holder, int f, int w, int h) { 
234 |     	if (thread != null)
235 |     		thread.setSurfaceSize(w, h);
236 |     	
237 |     	lastW = w;
238 |     	lastH = h;
239 |     }
240 | 
241 |     public void surfaceDestroyed(SurfaceHolder holder) { 
242 |         surfaceDone = false; 
243 |         stopPlayback(); 
244 |     }
245 | 
246 |     public MjpegView(Context context) { 
247 |         super(context);
248 |         init(context); 
249 |     }
250 | 
251 |     public void surfaceCreated(SurfaceHolder holder) { 
252 |         surfaceDone = true; 
253 |     }
254 | 
255 |     public void showFps(boolean b) { 
256 |         showFps = b; 
257 |     }
258 | 
259 |     public void setSource(MjpegInputStream source) { 
260 |         mIn = source;
261 |     }
262 | 
263 |     public void setOverlayPaint(Paint p) { 
264 |         overlayPaint = p; 
265 |     }
266 | 
267 |     public void setOverlayTextColor(int c) { 
268 |         overlayTextColor = c; 
269 |     }
270 | 
271 |     public void setOverlayBackgroundColor(int c) { 
272 |         overlayBackgroundColor = c; 
273 |     }
274 | 
275 |     public void setOverlayPosition(int p) { 
276 |         ovlPos = p; 
277 |     }
278 | 
279 |     public void setDisplayMode(int s) { 
280 |         displayMode = s; 
281 |     }
282 | 
283 |     public int getFrameDelay() {
284 | 		return frameDelay;
285 | 	}
286 | 
287 | 	public void setFrameDelay(int frameDelay) {
288 | 		this.frameDelay = frameDelay;
289 | 	}
290 | 
291 | }


--------------------------------------------------------------------------------
/src/info/guardianproject/iocipher/camera/viewer/MjpegViewerActivity.java:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * 
  3 |  * This file contains code from the IOCipher Camera Library "CipherCam".
  4 |  *
  5 |  * For more information about IOCipher, see https://guardianproject.info/code/iocipher
  6 |  * and this sample library: https://github.com/n8fr8/IOCipherCameraExample
  7 |  *
  8 |  * IOCipher Camera Sample is distributed under this license (aka the 3-clause BSD license)
  9 |  *
 10 |  * @author n8fr8
 11 |  * 
 12 |  */
 13 | 
 14 | package info.guardianproject.iocipher.camera.viewer;
 15 | 
 16 | 
 17 | import info.guardianproject.iocipher.File;
 18 | import info.guardianproject.iocipher.FileInputStream;
 19 | import info.guardianproject.iocipher.camera.MediaConstants;
 20 | import info.guardianproject.iocipher.camera.encoders.AACHelper;
 21 | 
 22 | import java.io.BufferedInputStream;
 23 | import java.io.IOException;
 24 | import java.io.InputStream;
 25 | 
 26 | import android.app.Activity;
 27 | import android.media.AudioFormat;
 28 | import android.media.AudioManager;
 29 | import android.media.AudioTrack;
 30 | import android.os.Bundle;
 31 | import android.util.Log;
 32 | import android.view.Window;
 33 | import android.view.WindowManager;
 34 | 
 35 | public class MjpegViewerActivity extends Activity {
 36 |     private static final String TAG = "MjpegActivity";
 37 | 
 38 |     private MjpegView mv;
 39 |     private AudioTrack at;
 40 | 
 41 |     InputStream isAudio = null;
 42 |     AACHelper aac = null;
 43 |     boolean useAAC = false;
 44 |     
 45 |     public void onCreate(Bundle savedInstanceState) {
 46 |         super.onCreate(savedInstanceState);
 47 | 
 48 |         requestWindowFeature(Window.FEATURE_NO_TITLE);
 49 |         getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, 
 50 |         WindowManager.LayoutParams.FLAG_FULLSCREEN);
 51 | 
 52 |       //prevent screenshots
 53 |       		getWindow().setFlags(WindowManager.LayoutParams.FLAG_SECURE,
 54 |       				WindowManager.LayoutParams.FLAG_SECURE);
 55 |       		
 56 |         mv = new MjpegView(this);
 57 |         setContentView(mv);        
 58 | 
 59 |         final String ioCipherVideoPath = getIntent().getExtras().getString("video");
 60 |         final String ioCipherAudioPath = getIntent().getExtras().getString("audio");
 61 |         
 62 |         try {
 63 | 
 64 | 	        mv.setDisplayMode(MjpegView.SIZE_BEST_FIT);
 65 | 	        //mv.showFps(false);
 66 | 	        mv.setFrameDelay(2); //we need to better sync each frame to the audio
 67 | 	        
 68 | 			File fileAudio = null;
 69 | 			
 70 | 			if (ioCipherAudioPath == null)
 71 | 			{
 72 | 				fileAudio = new File(ioCipherVideoPath + ".pcm");
 73 | 				if (!fileAudio.exists())
 74 | 				{
 75 | 					fileAudio = new File(ioCipherVideoPath + ".aac");
 76 | 					useAAC = true;
 77 | 				}
 78 | 			}
 79 | 			else
 80 | 			{
 81 | 				fileAudio = new File(ioCipherAudioPath);
 82 | 				
 83 | 				if (getIntent().getExtras().containsKey("useAAC"))
 84 | 					useAAC = getIntent().getExtras().getBoolean("useAAC",false);
 85 | 				else if (ioCipherAudioPath.endsWith(".aac"))
 86 | 					useAAC = true;
 87 | 			}
 88 | 			
 89 | 			if (fileAudio.exists())
 90 | 			{
 91 | 				initAudio(fileAudio.getAbsolutePath());
 92 | 				new Thread ()
 93 | 				{
 94 | 					public void run ()
 95 | 					{
 96 | 						try {							
 97 | 							playAudio();
 98 | 						} catch (Exception e) {
 99 | 							// TODO Auto-generated catch block
100 | 							e.printStackTrace();
101 | 						}
102 | 					}
103 | 				}.start();
104 | 			}
105 | 			mv.setSource(new MjpegInputStream(new FileInputStream(ioCipherVideoPath)));
106 | 	        
107 | 
108 | 		        
109 | 	    	} 
110 |         catch (Exception e) {
111 | 			
112 | 			Log.e(TAG,"an error occcured init'g video playback",e);
113 | 		}
114 |     }
115 |     
116 |     public void initAudio(String vfsPath) throws Exception {
117 | 
118 |     	isAudio = new BufferedInputStream(new FileInputStream(vfsPath));
119 | 
120 |     	if (useAAC)
121 |     	{
122 |     		aac = new AACHelper();
123 |     		aac.setDecoder(MediaConstants.sAudioSampleRate, MediaConstants.sAudioChannels, MediaConstants.sAudioBitRate);
124 |     	}
125 |     	else
126 |     	{
127 | 	
128 | 	        int minBufferSize = AudioTrack.getMinBufferSize(MediaConstants.sAudioSampleRate,
129 | 	        		MediaConstants.sChannelConfigOut, AudioFormat.ENCODING_PCM_16BIT)*8;
130 | 	
131 | 	        at = new AudioTrack(AudioManager.STREAM_MUSIC, MediaConstants.sAudioSampleRate,
132 | 	        		MediaConstants.sChannelConfigOut, AudioFormat.ENCODING_PCM_16BIT,
133 | 	            minBufferSize, AudioTrack.MODE_STREAM);
134 | 	        
135 |     	}
136 |          
137 |     }
138 |     
139 |     public void playAudio () throws IOException
140 |     {
141 |     	if (useAAC)
142 |     		aac.startPlaying(isAudio);
143 |     	else
144 |     	{
145 | 	        try{
146 | 	        	byte[] music = null;
147 | 	        	music = new byte[512];
148 | 	            at.play();
149 | 	
150 | 	            int i = 0;
151 | 	            while((i = isAudio.read(music)) != -1)
152 | 	                at.write(music, 0, i);
153 | 	
154 | 	        } catch (IOException e) {
155 | 	            e.printStackTrace();
156 | 	        }
157 | 	
158 | 	        at.stop();
159 | 	        at.release();
160 | 	        isAudio.close();
161 | 	        at = null;
162 |     	}
163 |     }
164 | 
165 |     public void onPause() {
166 |         super.onPause();
167 |         mv.stopPlayback();
168 |         
169 |         if (at!=null)
170 |         	at.stop();
171 |         
172 |     }
173 | 
174 | }


--------------------------------------------------------------------------------
/src/info/guardianproject/iocipher/camera/viewer/PZSImageView.java:
--------------------------------------------------------------------------------
  1 | package info.guardianproject.iocipher.camera.viewer;
  2 | 
  3 | import android.content.Context;
  4 | import android.graphics.Bitmap;
  5 | import android.graphics.Canvas;
  6 | import android.graphics.Matrix;
  7 | import android.graphics.PointF;
  8 | import android.graphics.Rect;
  9 | import android.graphics.RectF;
 10 | import android.util.AttributeSet;
 11 | import android.util.FloatMath;
 12 | import android.view.MotionEvent;
 13 | import android.widget.ImageView;
 14 | 
 15 | /**
 16 |  * class Pinch Zoom & Swipe Image View.
 17 |  * @author huewu.yang
 18 |  * @date 2012. 08. 23
 19 |  */
 20 | public class PZSImageView extends ImageView {
 21 | 
 22 | 	private static final String TAG = "GalleryImageView";	//debug tag.
 23 | 
 24 | 	//wrapped motion event code.
 25 | 	protected static final int PZS_ACTION_INIT = 100;
 26 | 	protected static final int PZS_ACTION_SCALE = 1001;
 27 | 	protected static final int PZS_ACTION_TRANSLATE = 1002;
 28 | 	protected static final int PZS_ACTION_SCALE_TO_TRANSLATE = 1003;
 29 | 	protected static final int PZS_ACTION_TRANSLATE_TO_SCALE = 1004;	
 30 | 	protected static final int PZS_ACTION_FIT_CENTER = 1005;
 31 | 	protected static final int PZS_ACTION_CANCEL = -1;
 32 | 
 33 | 	//TODO below 2 values should be able to set from attributes.
 34 | 	private final static float MAX_SCALE_TO_SCREEN = 2.f;
 35 | 	private final static float MIN_SCALE_TO_SCREEN = .5f;
 36 | 	
 37 | 	private static final long DOUBLE_TAP_MARGIN_TIME = 200;
 38 | 	private static final float MIN_SCALE_SPAN = 10.f;
 39 | 	
 40 | 	//calculated min / max scale ratio based on image & screen size.
 41 | 	private float mMinScaleFactor = 0.5f;	
 42 | 	private float mMaxScaleFactor = 2.f;
 43 | 
 44 | 	private boolean mIsFirstDraw = true;	//check flag to calculate necessary init values.
 45 | 	private int mImageWidth;	//current set image width
 46 | 	private int mImageHeight;	//current set image height
 47 | 
 48 | 	/**
 49 | 	 * constructor
 50 | 	 * @param context
 51 | 	 */
 52 | 	public PZSImageView(Context context) {
 53 | 		super(context);
 54 | 		init();
 55 | 	}
 56 | 
 57 | 	/**
 58 | 	 * constructor
 59 | 	 * @param context
 60 | 	 */
 61 | 	public PZSImageView(Context context, AttributeSet attrs) {
 62 | 		super(context, attrs);
 63 | 		init();
 64 | 	}
 65 | 
 66 | 	/**
 67 | 	 * constructor
 68 | 	 * @param context
 69 | 	 */
 70 | 	public PZSImageView(Context context, AttributeSet attrs, int defStyle) {
 71 | 		super(context, attrs, defStyle);
 72 | 		init();
 73 | 	}
 74 | 
 75 | 	private void init() {
 76 | 		//should use matrix scale type.
 77 | 		setScaleType(ScaleType.MATRIX);
 78 | 		Matrix mat = getImageMatrix();
 79 | 		mat.reset();
 80 | 		setImageMatrix(mat);
 81 | 	}
 82 | 	
 83 | 	//TODO how to handle bitmaps that set as different ways. (by res or src attr)
 84 | 	//TODO in that case this view should be worked just as a normal image view.
 85 | 	@Override
 86 | 	public void setImageBitmap(Bitmap bm) {
 87 | 		super.setImageBitmap(bm);
 88 | 
 89 | 		mIsFirstDraw = true;
 90 | 		mImageWidth = bm.getWidth();
 91 | 		mImageHeight = bm.getHeight();
 92 | 	}
 93 | 
 94 | 	@Override
 95 | 	protected void onDraw(Canvas canvas) {
 96 | 
 97 | 		if( mIsFirstDraw  == true ){
 98 | 			mIsFirstDraw = false;
 99 | 			fitCenter();
100 | 			calculateScaleFactorLimit();
101 | 		}
102 | 
103 | 		setImageMatrix(mCurrentMatrix);
104 | 
105 | 		super.onDraw(canvas);
106 | 	}
107 | 	
108 | 	private void calculateScaleFactorLimit() {
109 | 		
110 | 		//set max / min scale factor.
111 | 		mMaxScaleFactor = Math.max( getHeight() * MAX_SCALE_TO_SCREEN / mImageHeight,
112 | 				getWidth() * MAX_SCALE_TO_SCREEN / mImageWidth);
113 | 		
114 | 		mMinScaleFactor = Math.min( getHeight() * MIN_SCALE_TO_SCREEN / mImageHeight,
115 | 				getWidth() * MIN_SCALE_TO_SCREEN / mImageWidth);
116 | 	}
117 | 
118 | 	@Override
119 | 	public boolean onTouchEvent(MotionEvent event) {
120 | 
121 | 		int action = parseMotionEvent(event);
122 | 
123 | 		switch(action){
124 | 		case PZS_ACTION_INIT:
125 | 			initGestureAction(event.getX(), event.getY());
126 | 			break;
127 | 		case PZS_ACTION_SCALE:
128 | 			handleScale(event);
129 | 			break;
130 | 		case PZS_ACTION_TRANSLATE:
131 | 			handleTranslate(event);
132 | 			break;
133 | 		case PZS_ACTION_TRANSLATE_TO_SCALE:
134 | 			initGestureAction(event.getX(), event.getY());
135 | 			break;
136 | 		case PZS_ACTION_SCALE_TO_TRANSLATE:
137 | 			int activeIndex = (event.getActionIndex() == 0 ? 1 : 0);
138 | 			initGestureAction(event.getX(activeIndex), event.getY(activeIndex));
139 | 			break;
140 | 		case PZS_ACTION_FIT_CENTER:
141 | 			fitCenter();
142 | 			initGestureAction(event.getX(), event.getY());
143 | 			break;
144 | 		case PZS_ACTION_CANCEL:
145 | 			break;
146 | 		}
147 | 		
148 | 		//check current position of bitmap.
149 | 		validateMatrix();
150 | 		updateMatrix();
151 | 		return true; // indicate event was handled
152 | 	}
153 | 
154 | 	private int parseMotionEvent(MotionEvent ev) {
155 | 
156 | 		switch (ev.getAction() & MotionEvent.ACTION_MASK) {
157 | 		case MotionEvent.ACTION_DOWN:
158 | 			if( isDoubleTap(ev) )
159 | 				return PZS_ACTION_FIT_CENTER;
160 | 			else
161 | 				return PZS_ACTION_INIT;
162 | 		case MotionEvent.ACTION_POINTER_DOWN:
163 | 			//more than one pointer is pressed...
164 | 			return PZS_ACTION_TRANSLATE_TO_SCALE;
165 | 		case MotionEvent.ACTION_UP:
166 | 		case MotionEvent.ACTION_POINTER_UP:
167 | 			if( ev.getPointerCount() == 2 ){
168 | 				return PZS_ACTION_SCALE_TO_TRANSLATE;
169 | 			}else{
170 | 				return PZS_ACTION_INIT;
171 | 			}
172 | 		case MotionEvent.ACTION_MOVE:
173 | 			if( ev.getPointerCount() == 1 )
174 | 				return PZS_ACTION_TRANSLATE;
175 | 			else if( ev.getPointerCount() == 2 )
176 | 				return PZS_ACTION_SCALE;
177 | 			return 0;
178 | 		}
179 | 		return 0;
180 | 	}
181 | 
182 | 	/////////////////////////////////////////////////
183 | 	// Related matrix calculation stuffs.
184 | 	/////////////////////////////////////////////////	
185 | 	
186 | 	private Matrix mCurrentMatrix = new Matrix();
187 | 	private Matrix mSavedMatrix = new Matrix();
188 | 
189 | 	// Remember some things for zooming
190 | 	private PointF mStartPoint = new PointF();
191 | 	private PointF mMidPoint = new PointF();
192 | 	private float mInitScaleSpan = 1f;
193 | 	
194 | 	protected void initGestureAction(float x, float y) {
195 | 		mSavedMatrix.set(mCurrentMatrix);
196 | 		mStartPoint.set(x, y);
197 | 		mInitScaleSpan = 0.f;
198 | 	}
199 | 
200 | 	/**
201 | 	 * check user double tapped this view.. or not.
202 | 	 * @param current motion event.
203 | 	 * @return true if user double tapped this view.
204 | 	 */
205 | 	private long mLastTocuhDownTime = 0;
206 | 	protected boolean isDoubleTap(MotionEvent ev){
207 | 		//if old pointer is tapped?
208 | 		if( ev.getPointerCount() > 1){
209 | 			//if there are more than one pointer... reset
210 | 			mLastTocuhDownTime = 0;
211 | 			return false;
212 | 		}
213 | 
214 | 		long downTime = ev.getDownTime();
215 | 		long diff = downTime - mLastTocuhDownTime;
216 | 		mLastTocuhDownTime = downTime;
217 | 
218 | 		return diff < DOUBLE_TAP_MARGIN_TIME;
219 | 	}
220 | 
221 | 	protected void handleScale(MotionEvent event){
222 | 		float newSpan = spacing(event);
223 | 
224 | 		//if two finger is too close, pointer index is bumped.. so just ignore it.
225 | 		if( newSpan < MIN_SCALE_SPAN )
226 | 			return;
227 | 
228 | 		if( mInitScaleSpan == 0.f ){
229 | 			//init values. scale gesture action is just started.
230 | 			mInitScaleSpan = newSpan;
231 | 			midPoint(mMidPoint, event);
232 | 		}else{
233 | 			float scale = normalizeScaleFactor(mSavedMatrix, newSpan, mInitScaleSpan);
234 | 			mCurrentMatrix.set(mSavedMatrix);
235 | 			mCurrentMatrix.postScale(scale, scale, mMidPoint.x, mMidPoint.y);
236 | 		}
237 | 	}
238 | 
239 | 	private float normalizeScaleFactor(Matrix curMat, float newSpan, float stdSpan) {
240 | 		
241 | 		float values[] = new float[9];
242 | 		curMat.getValues(values);
243 | 		float scale = values[Matrix.MSCALE_X];
244 | 			
245 | 		if( stdSpan == newSpan ){
246 | 			return scale;
247 | 		} else {
248 | 			float newScaleFactor = newSpan / stdSpan;
249 | 			float candinateScale = scale * newScaleFactor;
250 | 			
251 | 			if( candinateScale > mMaxScaleFactor ){
252 | 				return mMaxScaleFactor / scale;
253 | 			}else if( candinateScale < mMinScaleFactor ){
254 | 				return mMinScaleFactor / scale;
255 | 			}else{
256 | 				return newScaleFactor;
257 | 			}
258 | 		}
259 | 	}
260 | 	
261 | 	protected void handleTranslate(MotionEvent event){
262 | 		mCurrentMatrix.set(mSavedMatrix);
263 | 		mCurrentMatrix.postTranslate(event.getX() - mStartPoint.x, event.getY() - mStartPoint.y);
264 | 	}	
265 | 	
266 | 	private RectF mTraslateLimitRect = new RectF(); //reuse instance.
267 | 	private void validateMatrix(){
268 | 		float values[] = new float[9];
269 | 		mCurrentMatrix.getValues(values);
270 | 		
271 | 		//get current matrix values.
272 | 		float scale = values[Matrix.MSCALE_X];
273 | 		float tranX = values[Matrix.MTRANS_X];
274 | 		float tranY = values[Matrix.MTRANS_Y];
275 | 				
276 | 		int imageHeight = (int) (scale * mImageHeight);
277 | 		int imageWidth = (int) (scale * mImageWidth);
278 | 
279 | 		mTraslateLimitRect.setEmpty();
280 | 		//don't think about optimize code. first, just write code case by case.
281 | 
282 | 		//check TOP & BOTTOM
283 | 		if( imageHeight > getHeight() ){
284 | 			//image height is taller than view
285 | 			mTraslateLimitRect.top = getHeight() - imageHeight - getPaddingTop() - getPaddingBottom();
286 | 			mTraslateLimitRect.bottom = 0.f;
287 | 		}else{
288 | 			mTraslateLimitRect.top = mTraslateLimitRect.bottom =
289 | 					(getHeight() - imageHeight - getPaddingTop() - getPaddingBottom() ) / 2.f;
290 | 		}
291 | 
292 | 		//check LEFT & RIGHT
293 | 		if( imageWidth > getWidth() ){
294 | 			//image width is longer than view
295 | 			mTraslateLimitRect.left = getWidth() - imageWidth - getPaddingRight() - getPaddingLeft();
296 | 			mTraslateLimitRect.right = 0.f;
297 | 		}else{
298 | 			mTraslateLimitRect.left = mTraslateLimitRect.right =
299 | 					(getWidth() - imageWidth - getPaddingLeft() - getPaddingRight()) / 2.f;
300 | 		}
301 | 
302 | 		float newTranX = tranX;
303 | 		newTranX = Math.max(newTranX, mTraslateLimitRect.left);
304 | 		newTranX = Math.min(newTranX, mTraslateLimitRect.right);
305 | 
306 | 		float newTranY = tranY;
307 | 		newTranY = Math.max(newTranY, mTraslateLimitRect.top);
308 | 		newTranY = Math.min(newTranY, mTraslateLimitRect.bottom);
309 | 		
310 | 		values[Matrix.MTRANS_X] = newTranX;
311 | 		values[Matrix.MTRANS_Y] = newTranY;
312 | 		mCurrentMatrix.setValues(values);
313 | 		
314 | 		if( mTraslateLimitRect.contains(tranX, tranY) == false ){
315 | 			//set new start point.
316 | 			mStartPoint.offset(tranX - newTranX, tranY - newTranY);
317 | 		}
318 | 	}
319 | 	
320 | 	protected void updateMatrix(){
321 | 		setImageMatrix(mCurrentMatrix);
322 | 	}
323 | 
324 | 	protected void fitCenter(){
325 | 		//move image to center....
326 | 		mCurrentMatrix.reset();
327 | 
328 | 		float scaleX = (getWidth() - getPaddingLeft() - getPaddingRight()) / (float)mImageWidth;
329 | 		float scaleY = (getHeight() - getPaddingTop() - getPaddingBottom()) / (float)mImageHeight;
330 | 		float scale = Math.min(scaleX, scaleY);
331 | 
332 | 		float dx = (getWidth() - getPaddingLeft() - getPaddingRight() - mImageWidth * scale) / 2.f;
333 | 		float dy = (getHeight() - getPaddingTop() - getPaddingBottom() - mImageHeight * scale) / 2.f;
334 | 
335 | 		mCurrentMatrix.postScale(scale, scale);
336 | 		mCurrentMatrix.postTranslate(dx, dy);
337 | 		setImageMatrix(mCurrentMatrix);
338 | 	}
339 | 
340 | 	/** Determine the space between the first two fingers */
341 | 	private float spacing(MotionEvent event) {
342 | 		// ...
343 | 		float x = event.getX(0) - event.getX(1);
344 | 		float y = event.getY(0) - event.getY(1);
345 | 		return FloatMath.sqrt(x * x + y * y);
346 | 	}
347 | 
348 | 	/** Calculate the mid point of the first two fingers */
349 | 	private void midPoint(PointF point, MotionEvent event) {
350 | 		// ...
351 | 		float x = event.getX(0) + event.getX(1);
352 | 		float y = event.getY(0) + event.getY(1);
353 | 		point.set(x / 2, y / 2);
354 | 	}
355 | 
356 | }//end of class


--------------------------------------------------------------------------------
/src/info/guardianproject/iocipher/camera/viewer/StreamOverHttp.java:
--------------------------------------------------------------------------------
  1 | package info.guardianproject.iocipher.camera.viewer;
  2 | 
  3 | import java.io.BufferedReader;
  4 | import java.io.ByteArrayInputStream;
  5 | import java.io.File;
  6 | import java.io.IOException;
  7 | import java.io.InputStream;
  8 | import java.io.InputStreamReader;
  9 | import java.io.OutputStream;
 10 | import java.io.PrintWriter;
 11 | import java.net.ServerSocket;
 12 | import java.net.Socket;
 13 | import java.net.URLEncoder;
 14 | import java.util.Enumeration;
 15 | import java.util.Properties;
 16 | import java.util.StringTokenizer;
 17 | 
 18 | import android.net.Uri;
 19 | import android.util.Log;
 20 | 
 21 | /**
 22 |  * This is simple HTTP local server for streaming InputStream to apps which are capable to read data from url.
 23 |  * Random access input stream is optionally supported, depending if file can be opened in this mode. 
 24 |  *
 25 |  * from: http://stackoverflow.com/a/9096241
 26 |  */
 27 | public class StreamOverHttp{
 28 | 	
 29 |    private static boolean debug = false;
 30 |  
 31 |    private final File file;
 32 |    private final String fileMimeType;
 33 |    private long fileSize;
 34 |    private InputStream fileInputStream;
 35 |    private final ServerSocket serverSocket;
 36 |    private Thread mainThread;
 37 |  
 38 |    /**
 39 |     * Some HTTP response status codes
 40 |     */
 41 |    private static final String 
 42 |       HTTP_BADREQUEST = "400 Bad Request",
 43 |       HTTP_416 = "416 Range not satisfiable",
 44 |       HTTP_INTERNALERROR = "500 Internal Server Error";
 45 |  
 46 |    public StreamOverHttp(File f, String forceMimeType, long forceFileSize, InputStream fis, int serverPort) throws IOException{
 47 |       file = f;
 48 |       
 49 |       fileMimeType = forceMimeType;
 50 |       serverSocket = new ServerSocket(serverPort);
 51 |       fileSize = forceFileSize;
 52 |       fileInputStream = fis;
 53 |       
 54 |       if (debug)
 55 |     	  log ("streaming " + f.getAbsolutePath() + " type=" + fileMimeType + " len=" + fileSize);
 56 |       
 57 |       mainThread = new Thread(new Runnable(){
 58 |          @Override
 59 |          public void run(){
 60 |             try{
 61 |                while(true) {
 62 |                   Socket accept = serverSocket.accept();
 63 |                   new HttpSession(accept);
 64 |                }
 65 |             }catch(IOException e){
 66 |                log("socket closed: "+e);
 67 |             }
 68 |          }
 69 |  
 70 |       });
 71 |       mainThread.setName("Stream over HTTP");
 72 |       mainThread.setDaemon(true);
 73 |       mainThread.start();
 74 |    }
 75 |  
 76 |    private class HttpSession implements Runnable{
 77 |       private boolean canSeek;
 78 |       private InputStream is;
 79 |       private final Socket socket;
 80 |  
 81 |       HttpSession(Socket s){
 82 |          socket = s;
 83 |          log("Stream over localhost: serving request on "+s.getInetAddress());
 84 |          Thread t = new Thread(this, "Http response");
 85 |          t.setDaemon(true);
 86 |          t.start();
 87 |       }
 88 |  
 89 |       @Override
 90 |       public void run(){
 91 |          try{
 92 |             openInputStream();
 93 |             handleResponse(socket);
 94 |          }catch(IOException e){
 95 |             e.printStackTrace();
 96 |          }finally {
 97 |             if(is!=null) {
 98 |                try{
 99 |                   is.close();
100 |                }catch(IOException e){
101 |                   e.printStackTrace();
102 |                }
103 |             }
104 |          }
105 |       }
106 |  
107 |       private void openInputStream() throws IOException{
108 |          // openRandomAccessInputStream must return RandomAccessInputStream if file is ssekable, null otherwise
109 |          is = openRandomAccessInputStream(file);
110 |          if(is!=null)
111 |             canSeek = true;
112 |          else
113 |             is = openInputStream(file, 0);
114 |       }
115 |  
116 |       public InputStream openInputStream (File file, int value) throws IOException
117 |       {
118 |     	  return fileInputStream;
119 |       }
120 |       
121 |       
122 |       public RandomAccessInputStream openRandomAccessInputStream (File file) throws IOException
123 |       {
124 |     	  if (fileInputStream instanceof info.guardianproject.iocipher.FileInputStream)
125 |     		  fileInputStream = new info.guardianproject.iocipher.FileInputStream(file.getAbsolutePath());
126 |     	  else
127 |     		  fileInputStream = new java.io.FileInputStream(file);
128 |     	  
129 |     	  RandomAccessInputStream rais = new RandomAccessInputStream ()
130 |     	  {
131 | 
132 |     		  
133 | 			@Override
134 | 			public int available() throws IOException {
135 | 				
136 | 				return fileInputStream.available();
137 | 			}
138 | 
139 | 			@Override
140 | 			public void close() throws IOException {
141 | 				fileInputStream.close();
142 | 			}
143 | 
144 | 			@Override
145 | 			public void mark(int readlimit) {
146 | 				fileInputStream.mark(readlimit);
147 | 			}
148 | 
149 | 			@Override
150 | 			public boolean markSupported() {
151 | 				return fileInputStream.markSupported();
152 | 			}
153 | 
154 | 			@Override
155 | 			public int read(byte[] buffer, int byteOffset, int byteCount)
156 | 					throws IOException {
157 | 				return fileInputStream.read(buffer, byteOffset, byteCount);
158 | 			}
159 | 
160 | 			@Override
161 | 			public int read(byte[] buffer) throws IOException {
162 | 				return fileInputStream.read(buffer);
163 | 			}
164 | 
165 | 			@Override
166 | 			public synchronized void reset() throws IOException {
167 | 				fileInputStream.reset();
168 | 			}
169 | 
170 | 			@Override
171 | 			long length() {
172 | 				
173 | 				return fileSize;
174 | 			}
175 | 
176 | 			@Override
177 | 			void seek(long offset) throws IOException {
178 | 				
179 | 				fileInputStream.skip(offset);
180 | 				
181 | 			}
182 |     		  
183 |     	  };
184 |     	  
185 |     	 return rais;
186 |       }
187 |       
188 |       private void handleResponse(Socket socket){
189 |          try{
190 |             InputStream inS = socket.getInputStream();
191 |             if(inS == null)
192 |                return;
193 |             byte[] buf = new byte[8192];
194 |             int rlen = inS.read(buf, 0, buf.length);
195 |             if(rlen <= 0)
196 |                return;
197 |  
198 |             // Create a BufferedReader for parsing the header.
199 |             ByteArrayInputStream hbis = new ByteArrayInputStream(buf, 0, rlen);
200 |             BufferedReader hin = new BufferedReader(new InputStreamReader(hbis));
201 |             Properties pre = new Properties();
202 |  
203 |             // Decode the header into params and header java properties
204 |             if(!decodeHeader(socket, hin, pre))
205 |                return;
206 |             
207 |             String range = pre.getProperty("range");
208 |  
209 |             Properties headers = new Properties();
210 |             if(fileSize!=-1)
211 |                headers.put("Content-Length", String.valueOf(fileSize));
212 |             headers.put("Accept-Ranges", canSeek ? "bytes" : "none");
213 |  
214 |             int sendCount;
215 |  
216 |             String status;
217 |             if(range==null || !canSeek) {
218 |                status = "200 OK";
219 |                sendCount = (int)fileSize;
220 |             }else {
221 |                if(!range.startsWith("bytes=")){
222 |                   sendError(socket, HTTP_416, null);
223 |                   return;
224 |                }
225 |                if(debug)
226 |                   log(range);
227 |                range = range.substring(6);
228 |                long startFrom = 0, endAt = -1;
229 |                int minus = range.indexOf('-');
230 |                if(minus > 0){
231 |                   try{
232 |                      String startR = range.substring(0, minus);
233 |                      startFrom = Long.parseLong(startR);
234 |                      String endR = range.substring(minus + 1);
235 |                      endAt = Long.parseLong(endR);
236 |                   }catch(NumberFormatException nfe){
237 |                   }
238 |                }
239 |  
240 |                if(startFrom >= fileSize){
241 |                   sendError(socket, HTTP_416, null);
242 |                   inS.close();
243 |                   return;
244 |                }
245 |                if(endAt < 0)
246 |                   endAt = fileSize - 1;
247 |                sendCount = (int)(endAt - startFrom + 1);
248 |                if(sendCount < 0)
249 |                   sendCount = 0;
250 |                status = "206 Partial Content";
251 |                ((RandomAccessInputStream)is).seek(startFrom);
252 |  
253 |                headers.put("Content-Length", "" + sendCount);
254 |                String rangeSpec = "bytes " + startFrom + "-" + endAt + "/" + fileSize;
255 |                headers.put("Content-Range", rangeSpec);
256 |             }
257 |             sendResponse(socket, status, fileMimeType, headers, is, sendCount, buf, null);
258 |             inS.close();
259 |             if(debug)
260 |                log("Http stream finished");
261 |          }catch(IOException ioe){
262 |             if(debug)
263 |                ioe.printStackTrace();
264 |             try{
265 |                sendError(socket, HTTP_INTERNALERROR, "SERVER INTERNAL ERROR: IOException: " + ioe.getMessage());
266 |             }catch(Throwable t){
267 |             }
268 |          }catch(InterruptedException ie){
269 |             // thrown by sendError, ignore and exit the thread
270 |             if(debug)
271 |                ie.printStackTrace();
272 |          }
273 |       }
274 |  
275 |       private boolean decodeHeader(Socket socket, BufferedReader in, Properties pre) throws InterruptedException{
276 |          try{
277 |             // Read the request line
278 |             String inLine = in.readLine();
279 |             if(inLine == null)
280 |                return false;
281 |             StringTokenizer st = new StringTokenizer(inLine);
282 |             if(!st.hasMoreTokens())
283 |                sendError(socket, HTTP_BADREQUEST, "Syntax error");
284 |  
285 |             String method = st.nextToken();
286 |             if(!method.equals("GET"))
287 |                return false;
288 |  
289 |             if(!st.hasMoreTokens())
290 |                sendError(socket, HTTP_BADREQUEST, "Missing URI");
291 |  
292 |             while(true) {
293 |                String line = in.readLine();
294 |                if(line==null)
295 |                   break;
296 |    //            if(debug && line.length()>0) log(line);
297 |                int p = line.indexOf(':');
298 |                if(p<0)
299 |                   continue;
300 |                final String atr = line.substring(0, p).trim().toLowerCase();
301 |                final String val = line.substring(p + 1).trim();
302 |                pre.put(atr, val);
303 |                
304 |                if (debug)
305 |             	   log ("header=" + atr + ": " + val);
306 |             }
307 |          }catch(IOException ioe){
308 |             sendError(socket, HTTP_INTERNALERROR, "SERVER INTERNAL ERROR: IOException: " + ioe.getMessage());
309 |          }
310 |          return true;
311 |       }
312 |    }
313 |  
314 |  
315 |    /**
316 |     * @param fileName is display name appended to Uri, not really used (may be null), but client may display it as file name.
317 |     * @return Uri where this stream listens and servers.
318 |     */
319 |    public Uri getUri(String fileName){
320 |       int port = serverSocket.getLocalPort();
321 |       String url = "http://localhost:"+port;
322 |       if(fileName!=null)
323 |          url += '/'+URLEncoder.encode(fileName);
324 |       return Uri.parse(url);
325 |    }
326 |  
327 |    public void close(){
328 |       log("Closing stream over http");
329 |       try{
330 |          serverSocket.close();
331 |          mainThread.join();
332 |       }catch(Exception e){
333 |          e.printStackTrace();
334 |       }
335 |    }
336 |  
337 |    /**
338 |     * Returns an error message as a HTTP response and
339 |     * throws InterruptedException to stop further request processing.
340 |     */
341 |    private static void sendError(Socket socket, String status, String msg) throws InterruptedException{
342 |       sendResponse(socket, status, "text/plain", null, null, 0, null, msg);
343 |       throw new InterruptedException();
344 |    }
345 |  
346 |   private static void copyStream(InputStream in, OutputStream out, byte[] tmpBuf, long maxSize) throws IOException{
347 |  
348 |      while(maxSize>0){
349 |         int count = (int)Math.min(maxSize, tmpBuf.length);
350 |         count = in.read(tmpBuf, 0, count);
351 |         if(count<0)
352 |            break;
353 |         out.write(tmpBuf, 0, count);
354 |         maxSize -= count;
355 |      }
356 |   }
357 |    /**
358 |     * Sends given response to the socket, and closes the socket.
359 |     */
360 |    private static void sendResponse(Socket socket, String status, String mimeType, Properties header, InputStream isInput, int sendCount, byte[] buf, String errMsg){
361 |       try{
362 |          OutputStream out = socket.getOutputStream();
363 |          PrintWriter pw = new PrintWriter(out);
364 |  
365 |          {
366 |             String retLine = "HTTP/1.0 " + status + " \r\n";
367 |             pw.print(retLine);
368 |          }
369 |          if(mimeType!=null) {
370 |             String mT = "Content-Type: " + mimeType + "\r\n";
371 |             pw.print(mT);
372 |          }
373 |          if(header != null){
374 |             Enumeration<?> e = header.keys();
375 |             while(e.hasMoreElements()){
376 |                String key = (String)e.nextElement();
377 |                String value = header.getProperty(key);
378 |                String l = key + ": " + value + "\r\n";
379 |                if(debug) log(l);
380 |                pw.print(l);
381 |             }
382 |          }
383 |          pw.print("\r\n");
384 |          pw.flush();
385 |          if(isInput!=null)
386 |             copyStream(isInput, out, buf, sendCount);
387 |          else if(errMsg!=null) {
388 |             pw.print(errMsg);
389 |             pw.flush();
390 |          }
391 |          out.flush();
392 |          out.close();
393 |       }catch(IOException e){
394 |          if(debug)
395 |             log(e.getMessage());
396 |       }finally {
397 |          try{
398 |             socket.close();
399 |          }catch(Throwable t){
400 |          }
401 |       }
402 |    }
403 |    
404 |    private final static void log (String msg)
405 |    {
406 | 	   if (debug)
407 | 		   Log.d("StreamProxy",msg);
408 |    }
409 | }
410 |  
411 | /**
412 |  * Seekable InputStream.
413 |  * Abstract, you must add implementation for your purpose.
414 |  */
415 | abstract class RandomAccessInputStream extends InputStream{
416 |  
417 |    /**
418 |     * @return total length of stream (file)
419 |     */
420 |    abstract long length();
421 |  
422 |    /**
423 |     * Seek within stream for next read-ing.
424 |     */
425 |    abstract void seek(long offset) throws IOException;
426 |  
427 |    @Override
428 |    public int read() throws IOException{
429 |       byte[] b = new byte[1];
430 |       read(b);
431 |       return b[0]&0xff;
432 |    }
433 | }


--------------------------------------------------------------------------------
/src/info/guardianproject/iocipher/camera/viewer/VideoViewerActivity.java:
--------------------------------------------------------------------------------
  1 | 
  2 | /**
  3 |  * 
  4 |  * This file contains code from the IOCipher Camera Library "CipherCam".
  5 |  *
  6 |  * For more information about IOCipher, see https://guardianproject.info/code/iocipher
  7 |  * and this sample library: https://github.com/n8fr8/IOCipherCameraExample
  8 |  *
  9 |  * IOCipher Camera Sample is distributed under this license (aka the 3-clause BSD license)
 10 |  *
 11 |  * @author n8fr8
 12 |  * 
 13 |  */
 14 | package info.guardianproject.iocipher.camera.viewer;
 15 | 
 16 | import info.guardianproject.iocipher.camera.R;
 17 | import android.app.Activity;
 18 | import android.media.AudioManager;
 19 | import android.media.MediaPlayer;
 20 | import android.media.MediaPlayer.OnBufferingUpdateListener;
 21 | import android.media.MediaPlayer.OnCompletionListener;
 22 | import android.media.MediaPlayer.OnPreparedListener;
 23 | import android.media.MediaPlayer.OnVideoSizeChangedListener;
 24 | import android.net.Uri;
 25 | import android.os.Bundle;
 26 | import android.util.Log;
 27 | import android.view.SurfaceHolder;
 28 | import android.view.SurfaceView;
 29 | import android.view.WindowManager;
 30 | 
 31 | public class VideoViewerActivity extends Activity implements
 32 | OnBufferingUpdateListener, OnCompletionListener, OnPreparedListener,
 33 | OnVideoSizeChangedListener, SurfaceHolder.Callback {
 34 | 
 35 | private static final String TAG = "MediaPlayerDemo";
 36 | private int mVideoWidth;
 37 | private int mVideoHeight;
 38 | private MediaPlayer mMediaPlayer;
 39 | private SurfaceView mPreview;
 40 | private SurfaceHolder holder;
 41 | private Bundle extras;
 42 | private static final String MEDIA = "media";
 43 | private static final int LOCAL_AUDIO = 1;
 44 | private static final int STREAM_AUDIO = 2;
 45 | private static final int RESOURCES_AUDIO = 3;
 46 | private static final int LOCAL_VIDEO = 4;
 47 | private static final int STREAM_VIDEO = 5;
 48 | private boolean mIsVideoSizeKnown = false;
 49 | private boolean mIsVideoReadyToBePlayed = false;
 50 | 
 51 | /**
 52 | * 
 53 | * Called when the activity is first created.
 54 | */
 55 | @Override
 56 | public void onCreate(Bundle icicle) {
 57 | super.onCreate(icicle);
 58 | 
 59 | //prevent screenshots
 60 | 		getWindow().setFlags(WindowManager.LayoutParams.FLAG_SECURE,
 61 | 				WindowManager.LayoutParams.FLAG_SECURE);
 62 | 		
 63 | 		
 64 | setContentView(R.layout.videoview);
 65 | mPreview = (SurfaceView) findViewById(R.id.surface_video);
 66 | holder = mPreview.getHolder();
 67 | holder.addCallback(this);
 68 | holder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
 69 | extras = getIntent().getExtras();
 70 | 
 71 | }
 72 | 
 73 | private void playVideo(Uri uri) {
 74 | doCleanUp();
 75 | try {
 76 | 
 77 | 
 78 |   // Create a new media player and set the listeners
 79 |   mMediaPlayer = new MediaPlayer();
 80 |   mMediaPlayer.setDataSource(this, uri);
 81 |   mMediaPlayer.setDisplay(holder);
 82 |   mMediaPlayer.prepare();
 83 |   mMediaPlayer.setOnBufferingUpdateListener(this);
 84 |   mMediaPlayer.setOnCompletionListener(this);
 85 |   mMediaPlayer.setOnPreparedListener(this);
 86 |   mMediaPlayer.setOnVideoSizeChangedListener(this);
 87 |   mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
 88 | 
 89 | } catch (Exception e) {
 90 |   Log.e(TAG, "error: " + e.getMessage(), e);
 91 | }
 92 | }
 93 | 
 94 | public void onBufferingUpdate(MediaPlayer arg0, int percent) {
 95 | Log.d(TAG, "onBufferingUpdate percent:" + percent);
 96 | 
 97 | }
 98 | 
 99 | public void onCompletion(MediaPlayer arg0) {
100 | Log.d(TAG, "onCompletion called");
101 | finish();
102 | }
103 | 
104 | public void onVideoSizeChanged(MediaPlayer mp, int width, int height) {
105 | Log.v(TAG, "onVideoSizeChanged called");
106 | if (width == 0 || height == 0) {
107 |   Log.e(TAG, "invalid video width(" + width + ") or height(" + height
108 |       + ")");
109 |   return;
110 | }
111 | mIsVideoSizeKnown = true;
112 | mVideoWidth = width;
113 | mVideoHeight = height;
114 | if (mIsVideoReadyToBePlayed && mIsVideoSizeKnown) {
115 |   startVideoPlayback();
116 | }
117 | }
118 | 
119 | public void onPrepared(MediaPlayer mediaplayer) {
120 | Log.d(TAG, "onPrepared called");
121 | mIsVideoReadyToBePlayed = true;
122 | if (mIsVideoReadyToBePlayed && mIsVideoSizeKnown) {
123 |   startVideoPlayback();
124 | }
125 | }
126 | 
127 | public void surfaceChanged(SurfaceHolder surfaceholder, int i, int j, int k) {
128 | Log.d(TAG, "surfaceChanged called");
129 | 
130 | }
131 | 
132 | public void surfaceDestroyed(SurfaceHolder surfaceholder) {
133 | Log.d(TAG, "surfaceDestroyed called");
134 | }
135 | 
136 | public void surfaceCreated(SurfaceHolder holder) {
137 | 	
138 | Log.d(TAG, "surfaceCreated called");
139 | playVideo(getIntent().getData());
140 | 
141 | }
142 | 
143 | @Override
144 | protected void onPause() {
145 | super.onPause();
146 | releaseMediaPlayer();
147 | doCleanUp();
148 | }
149 | 
150 | @Override
151 | protected void onDestroy() {
152 | super.onDestroy();
153 | releaseMediaPlayer();
154 | doCleanUp();
155 | }
156 | 
157 | private void releaseMediaPlayer() {
158 | if (mMediaPlayer != null) {
159 |   mMediaPlayer.release();
160 |   mMediaPlayer = null;
161 | }
162 | }
163 | 
164 | private void doCleanUp() {
165 | mVideoWidth = 0;
166 | mVideoHeight = 0;
167 | mIsVideoReadyToBePlayed = false;
168 | mIsVideoSizeKnown = false;
169 | }
170 | 
171 | private void startVideoPlayback() {
172 | Log.v(TAG, "startVideoPlayback");
173 | holder.setFixedSize(mVideoWidth, mVideoHeight);
174 | mMediaPlayer.start();
175 | }
176 | }


--------------------------------------------------------------------------------
/web_hi_res_512.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/guardianproject/CamCipher/fedaa54cd5d59b127df95270d0842214df74cd70/web_hi_res_512.png


--------------------------------------------------------------------------------