attachments page

src/Android/Android.csproj

@@ -100,6 +100,7 @@
     <Compile Include="Services\CryptoPrimitiveService.cs" />
     <Compile Include="Services\DeviceActionService.cs" />
     <Compile Include="Services\LocalizeService.cs" />
+    <Compile Include="Utilities\AndroidHelpers.cs" />
   </ItemGroup>
   <ItemGroup>
     <AndroidAsset Include="Assets\FontAwesome.ttf" />

src/Android/MainActivity.cs

@@ -2,6 +2,15 @@
 using Android.Content.PM;
 using Android.Runtime;
 using Android.OS;
+using Bit.Core;
+using System.Linq;
+using Bit.App.Abstractions;
+using Bit.Core.Utilities;
+using Bit.Core.Abstractions;
+using System.IO;
+using System;
+using Android.Content;
+using Bit.Droid.Utilities;
 
 namespace Bit.Droid
 {
@@ -14,8 +23,14 @@ namespace Bit.Droid
     [Register("com.x8bit.bitwarden.MainActivity")]
     public class MainActivity : Xamarin.Forms.Platform.Android.FormsAppCompatActivity
     {
+        private IDeviceActionService _deviceActionService;
+        private IMessagingService _messagingService;
+
         protected override void OnCreate(Bundle savedInstanceState)
         {
+            _deviceActionService = ServiceContainer.Resolve<IDeviceActionService>("deviceActionService");
+            _messagingService = ServiceContainer.Resolve<IMessagingService>("messagingService");
+
             TabLayoutResource = Resource.Layout.Tabbar;
             ToolbarResource = Resource.Layout.Toolbar;
 
@@ -25,11 +40,63 @@ namespace Bit.Droid
             LoadApplication(new App.App());
         }
 
-        public override void OnRequestPermissionsResult(int requestCode, string[] permissions,
+        public async override void OnRequestPermissionsResult(int requestCode, string[] permissions,
             [GeneratedEnum] Permission[] grantResults)
         {
-            Xamarin.Essentials.Platform.OnRequestPermissionsResult(requestCode, permissions, grantResults);
+            if(requestCode == Constants.SelectFilePermissionRequestCode)
+            {
+                if(grantResults.Any(r => r != Permission.Granted))
+                {
+                    _messagingService.Send("selectFileCameraPermissionDenied");
+                }
+                await _deviceActionService.SelectFileAsync();
+            }
+            else
+            {
+                Xamarin.Essentials.Platform.OnRequestPermissionsResult(requestCode, permissions, grantResults);
+            }
             base.OnRequestPermissionsResult(requestCode, permissions, grantResults);
         }
+
+        protected override void OnActivityResult(int requestCode, Result resultCode, Intent data)
+        {
+            if(requestCode == Constants.SelectFileRequestCode && resultCode == Result.Ok)
+            {
+                Android.Net.Uri uri = null;
+                string fileName = null;
+                if(data != null && data.Data != null)
+                {
+                    uri = data.Data;
+                    fileName = AndroidHelpers.GetFileName(ApplicationContext, uri);
+                }
+                else
+                {
+                    // camera
+                    var root = new Java.IO.File(Android.OS.Environment.ExternalStorageDirectory, "bitwarden");
+                    var file = new Java.IO.File(root, "temp_camera_photo.jpg");
+                    uri = Android.Net.Uri.FromFile(file);
+                    fileName = $"photo_{DateTime.UtcNow.ToString("yyyyMMddHHmmss")}.jpg";
+                }
+
+                if(uri == null)
+                {
+                    return;
+                }
+                try
+                {
+                    using(var stream = ContentResolver.OpenInputStream(uri))
+                    using(var memoryStream = new MemoryStream())
+                    {
+                        stream.CopyTo(memoryStream);
+                        _messagingService.Send("selectFileResult",
+                            new Tuple<byte[], string>(memoryStream.ToArray(), fileName ?? "unknown_file_name"));
+                    }
+                }
+                catch(Java.IO.FileNotFoundException)
+                {
+                    return;
+                }
+            }
+        }
     }
 }

src/Android/MainApplication.cs

@@ -54,7 +54,8 @@ namespace Bit.Droid
             var secureStorageService = new SecureStorageService();
             var cryptoPrimitiveService = new CryptoPrimitiveService();
             var mobileStorageService = new MobileStorageService(preferencesStorage, liteDbStorage);
-            var deviceActionService = new DeviceActionService(mobileStorageService);
+            var deviceActionService = new DeviceActionService(mobileStorageService, messagingService,
+                broadcasterService);
             var platformUtilsService = new MobilePlatformUtilsService(deviceActionService, messagingService,
                 broadcasterService);
 

src/Android/Services/DeviceActionService.cs

@@ -1,9 +1,14 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Threading.Tasks;
+using Android;
 using Android.App;
 using Android.Content;
 using Android.Content.PM;
+using Android.OS;
+using Android.Provider;
+using Android.Support.V4.App;
 using Android.Support.V4.Content;
 using Android.Webkit;
 using Android.Widget;
@@ -19,13 +24,28 @@ namespace Bit.Droid.Services
     public class DeviceActionService : IDeviceActionService
     {
         private readonly IStorageService _storageService;
-
+        private readonly IMessagingService _messagingService;
+        private readonly IBroadcasterService _broadcasterService;
         private ProgressDialog _progressDialog;
-        private Android.Widget.Toast _toast;
+        private bool _cameraPermissionsDenied;
+        private Toast _toast;
 
-        public DeviceActionService(IStorageService storageService)
+        public DeviceActionService(
+            IStorageService storageService,
+            IMessagingService messagingService,
+            IBroadcasterService broadcasterService)
         {
             _storageService = storageService;
+            _messagingService = messagingService;
+            _broadcasterService = broadcasterService;
+
+            _broadcasterService.Subscribe(nameof(DeviceActionService), (message) =>
+            {
+                if(message.Command == "selectFileCameraPermissionDenied")
+                {
+                    _cameraPermissionsDenied = true;
+                }
+            });
         }
 
         public DeviceType DeviceType => DeviceType.Android;
@@ -39,7 +59,7 @@ namespace Bit.Droid.Services
                 _toast = null;
             }
             _toast = Android.Widget.Toast.MakeText(CrossCurrentActivity.Current.Activity, text,
-                longDuration ? Android.Widget.ToastLength.Long : Android.Widget.ToastLength.Short);
+                longDuration ? ToastLength.Long : ToastLength.Short);
             _toast.Show();
         }
 
@@ -149,6 +169,54 @@ namespace Bit.Droid.Services
             catch(Exception) { }
         }
 
+        public Task SelectFileAsync()
+        {
+            var activity = (MainActivity)CrossCurrentActivity.Current.Activity;
+            var hasStorageWritePermission = !_cameraPermissionsDenied && HasPermission(Manifest.Permission.WriteExternalStorage);
+            var additionalIntents = new List<IParcelable>();
+            if(activity.PackageManager.HasSystemFeature(PackageManager.FeatureCamera))
+            {
+                var hasCameraPermission = !_cameraPermissionsDenied && HasPermission(Manifest.Permission.Camera);
+                if(!_cameraPermissionsDenied && !hasStorageWritePermission)
+                {
+                    AskPermission(Manifest.Permission.WriteExternalStorage);
+                    return Task.FromResult(0);
+                }
+                if(!_cameraPermissionsDenied && !hasCameraPermission)
+                {
+                    AskPermission(Manifest.Permission.Camera);
+                    return Task.FromResult(0);
+                }
+                if(!_cameraPermissionsDenied && hasCameraPermission && hasStorageWritePermission)
+                {
+                    try
+                    {
+                        var root = new Java.IO.File(Android.OS.Environment.ExternalStorageDirectory, "bitwarden");
+                        var file = new Java.IO.File(root, "temp_camera_photo.jpg");
+                        if(!file.Exists())
+                        {
+                            file.ParentFile.Mkdirs();
+                            file.CreateNewFile();
+                        }
+                        var outputFileUri = Android.Net.Uri.FromFile(file);
+                        additionalIntents.AddRange(GetCameraIntents(outputFileUri));
+                    }
+                    catch(Java.IO.IOException) { }
+                }
+            }
+
+            var docIntent = new Intent(Intent.ActionOpenDocument);
+            docIntent.AddCategory(Intent.CategoryOpenable);
+            docIntent.SetType("*/*");
+            var chooserIntent = Intent.CreateChooser(docIntent, AppResources.FileSource);
+            if(additionalIntents.Count > 0)
+            {
+                chooserIntent.PutExtra(Intent.ExtraInitialIntents, additionalIntents.ToArray());
+            }
+            activity.StartActivityForResult(chooserIntent, Constants.SelectFileRequestCode);
+            return Task.FromResult(0);
+        }
+
         public Task<string> DisplayPromptAync(string title = null, string description = null,
             string text = null, string okButtonText = null, string cancelButtonText = null)
         {
@@ -217,5 +285,35 @@ namespace Bit.Droid.Services
                 return false;
             }
         }
+
+        private bool HasPermission(string permission)
+        {
+            return ContextCompat.CheckSelfPermission(
+                CrossCurrentActivity.Current.Activity, permission) == Permission.Granted;
+        }
+
+        private void AskPermission(string permission)
+        {
+            ActivityCompat.RequestPermissions(CrossCurrentActivity.Current.Activity, new string[] { permission },
+                Constants.SelectFilePermissionRequestCode);
+        }
+
+        private List<IParcelable> GetCameraIntents(Android.Net.Uri outputUri)
+        {
+            var intents = new List<IParcelable>();
+            var pm = CrossCurrentActivity.Current.Activity.PackageManager;
+            var captureIntent = new Intent(MediaStore.ActionImageCapture);
+            var listCam = pm.QueryIntentActivities(captureIntent, 0);
+            foreach(var res in listCam)
+            {
+                var packageName = res.ActivityInfo.PackageName;
+                var intent = new Intent(captureIntent);
+                intent.SetComponent(new ComponentName(packageName, res.ActivityInfo.Name));
+                intent.SetPackage(packageName);
+                intent.PutExtra(MediaStore.ExtraOutput, outputUri);
+                intents.Add(intent);
+            }
+            return intents;
+        }
     }
 }

src/Android/Utilities/AndroidHelpers.cs

@@ -0,0 +1,30 @@
+using Android.Content;
+using Android.Provider;
+
+namespace Bit.Droid.Utilities
+{
+    public static class AndroidHelpers
+    {
+        public static string GetFileName(Context context, Android.Net.Uri uri)
+        {
+            string name = null;
+            string[] projection = { MediaStore.MediaColumns.DisplayName };
+            var metaCursor = context.ContentResolver.Query(uri, projection, null, null, null);
+            if(metaCursor != null)
+            {
+                try
+                {
+                    if(metaCursor.MoveToFirst())
+                    {
+                        name = metaCursor.GetString(0);
+                    }
+                }
+                finally
+                {
+                    metaCursor.Close();
+                }
+            }
+            return name;
+        }
+    }
+}