| // Copyright 2016 The Vanadium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package examples.baku.io.permissions.examples; |
| |
| import android.Manifest; |
| import android.app.Service; |
| import android.content.ComponentName; |
| import android.content.ContentResolver; |
| import android.content.Context; |
| import android.content.DialogInterface; |
| import android.content.Intent; |
| import android.content.ServiceConnection; |
| import android.content.pm.PackageManager; |
| import android.database.Cursor; |
| import android.graphics.Color; |
| import android.net.Uri; |
| import android.os.Bundle; |
| import android.os.IBinder; |
| import android.provider.ContactsContract; |
| import android.support.annotation.NonNull; |
| import android.support.design.widget.FloatingActionButton; |
| import android.support.v4.app.ActivityCompat; |
| import android.support.v4.content.ContextCompat; |
| import android.support.v7.app.AlertDialog; |
| import android.support.v7.app.AppCompatActivity; |
| import android.support.v7.widget.Toolbar; |
| import android.text.InputType; |
| import android.view.Menu; |
| import android.view.MenuItem; |
| import android.view.View; |
| import android.widget.ArrayAdapter; |
| import android.widget.ImageView; |
| import android.widget.RelativeLayout; |
| import android.widget.TextView; |
| import android.widget.Toast; |
| |
| import com.google.common.collect.HashMultimap; |
| import com.google.common.collect.Multimap; |
| import com.google.firebase.database.DataSnapshot; |
| import com.google.firebase.database.DatabaseError; |
| import com.google.firebase.database.DatabaseReference; |
| import com.google.firebase.database.ValueEventListener; |
| import com.joanzapata.iconify.IconDrawable; |
| import com.joanzapata.iconify.fonts.MaterialIcons; |
| |
| import org.json.JSONException; |
| import org.json.JSONObject; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.UUID; |
| |
| import examples.baku.io.permissions.Blessing; |
| import examples.baku.io.permissions.PermissionManager; |
| import examples.baku.io.permissions.PermissionRequest; |
| import examples.baku.io.permissions.PermissionService; |
| import examples.baku.io.permissions.PermissionedTextLayout; |
| import examples.baku.io.permissions.R; |
| import examples.baku.io.permissions.discovery.DeviceData; |
| import examples.baku.io.permissions.discovery.DevicePickerActivity; |
| import examples.baku.io.permissions.synchronization.SyncText; |
| import examples.baku.io.permissions.synchronization.SyncTextDiff; |
| import examples.baku.io.permissions.util.Utils; |
| |
| public class ComposeActivity extends AppCompatActivity implements ServiceConnection { |
| |
| public final static String EXTRA_MESSAGE_ID = "messageId"; |
| public final static String EXTRA_MESSAGE_PATH = "messagePath"; |
| private final static int SELECT_ATTACHMENT = 1232; |
| |
| private String mPath; |
| |
| private String mOwner; |
| private String mDeviceId; |
| private String mId; |
| private PermissionService mPermissionService; |
| private PermissionManager mPermissionManager; |
| private DatabaseReference mMessageRef; |
| private DatabaseReference mSyncedMessageRef; |
| |
| private Blessing mSourceBlessing; |
| private Blessing mPublicBlessing; |
| private final Set<String> targetDevices = new HashSet<>(); |
| |
| |
| private String mGroup; |
| private String mAttachment; |
| private int mAttachmentPermission; |
| private RelativeLayout mAttachmentView; |
| private TextView mAttachmentText; |
| private ImageView mAttachmentIcon; |
| private ImageView mAttachmentCast; |
| |
| private PermissionedTextLayout mTo; |
| private PermissionedTextLayout mFrom; |
| private PermissionedTextLayout mSubject; |
| private PermissionedTextLayout mMessage; |
| |
| private Multimap<String, PermissionRequest> mRequests = HashMultimap.create(); |
| private HashMap<String, PermissionedTextLayout> mPermissionedFields = new HashMap<>(); |
| private HashMap<String, Integer> mPermissions = new HashMap<>(); |
| private HashMap<String, SyncText> syncTexts = new HashMap<>(); |
| |
| private ArrayAdapter<String> contactAdapter; |
| FloatingActionButton mFab; |
| private Menu mMenu; |
| |
| @Override |
| protected void onCreate(Bundle savedInstanceState) { |
| super.onCreate(savedInstanceState); |
| |
| |
| setContentView(R.layout.activity_compose); |
| Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); |
| toolbar.setTitle("Compose"); |
| setSupportActionBar(toolbar); |
| getSupportActionBar().setDisplayHomeAsUpEnabled(true); |
| getSupportActionBar().setDisplayShowHomeEnabled(true); |
| toolbar.setTitle("Compose"); |
| |
| |
| mFab = (FloatingActionButton) findViewById(R.id.fab); |
| |
| mTo = (PermissionedTextLayout) findViewById(R.id.composeTo); |
| |
| |
| mFrom = (PermissionedTextLayout) findViewById(R.id.composeFrom); |
| |
| mSubject = (PermissionedTextLayout) findViewById(R.id.composeSubject); |
| |
| mMessage = (PermissionedTextLayout) findViewById(R.id.composeMessage); |
| mMessage.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_FLAG_MULTI_LINE); |
| |
| mAttachmentView = (RelativeLayout) findViewById(R.id.composeAttachment); |
| mAttachmentText = (TextView) findViewById(R.id.composeAttachmentText); |
| mAttachmentIcon = (ImageView) findViewById(R.id.composeAttachmentIcon); |
| mAttachmentIcon.setImageDrawable(new IconDrawable(this, MaterialIcons.md_attach_file).actionBarSize()); |
| mAttachmentCast = (ImageView) findViewById(R.id.composeAttachmentCast); |
| mAttachmentCast.setImageDrawable(new IconDrawable(this, MaterialIcons.md_cast).actionBarSize()); |
| mAttachmentCast.setOnClickListener(new View.OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| if(mPublicBlessing != null){ |
| int current = mPublicBlessing.getPermissions(mPath + "/attachment"); |
| if((current & PermissionManager.FLAG_READ) == PermissionManager.FLAG_READ){ |
| mPublicBlessing.setPermissions(mPath + "/attachment", current & ~PermissionManager.FLAG_READ); |
| mAttachmentCast.setImageDrawable(new IconDrawable(ComposeActivity.this, MaterialIcons.md_cast).actionBarSize()); |
| }else{ |
| mPublicBlessing.setPermissions(mPath + "/attachment", current | PermissionManager.FLAG_READ); |
| mAttachmentCast.setImageDrawable(new IconDrawable(ComposeActivity.this, MaterialIcons.md_cancel).color(Color.RED).actionBarSize()); |
| } |
| } |
| } |
| }); |
| mAttachmentCast.setVisibility(View.GONE); |
| |
| setGroup("Inbox"); //default |
| setAttachment(null, mAttachmentPermission); |
| |
| getContactsPermission(); |
| |
| bindService(new Intent(this, PermissionService.class), this, Service.BIND_AUTO_CREATE); |
| } |
| |
| |
| @Override |
| public boolean onCreateOptionsMenu(Menu menu) { |
| // Inflate the menu; this adds items to the action bar if it is present. |
| getMenuInflater().inflate(R.menu.menu_compose, menu); |
| menu.findItem(R.id.action_cast).setIcon( |
| new IconDrawable(this, MaterialIcons.md_cast) |
| .color(Color.WHITE) |
| .actionBarSize()); |
| MenuItem deleteItem = menu.findItem(R.id.action_delete); |
| |
| MenuItem attachItem = menu.findItem(R.id.action_attach).setIcon( |
| new IconDrawable(this, MaterialIcons.md_attach_file) |
| .color(Color.WHITE) |
| .actionBarSize()); |
| attachItem.setVisible(false); |
| if (mOwner == null || !mOwner.equals(mDeviceId)) { |
| attachItem.setVisible(false); |
| deleteItem.setVisible(false); |
| } |
| mMenu = menu; |
| return true; |
| } |
| |
| @Override |
| public boolean onOptionsItemSelected(MenuItem item) { |
| // Handle action bar item clicks here. The action bar will |
| // automatically handle clicks on the Home/Up button, so long |
| // as you specify a parent activity in AndroidManifest.xml. |
| int id = item.getItemId(); |
| |
| if (id == R.id.action_delete) { |
| checkAndSendMessage(); //currently send and delete have the same result |
| } else if (id == R.id.action_cast) { |
| if (mPermissionService != null) { |
| Intent requestIntent = new Intent(ComposeActivity.this, DevicePickerActivity.class); |
| requestIntent.putExtra(DevicePickerActivity.EXTRA_REQUEST, DevicePickerActivity.REQUEST_DEVICE_ID); |
| requestIntent.putExtra(DevicePickerActivity.EXTRA_REQUEST_ARGS, mPath); |
| startActivityForResult(requestIntent, DevicePickerActivity.REQUEST_DEVICE_ID); |
| } |
| } else if (id == R.id.action_attach) { |
| pickAttachment(); |
| } else if (id == android.R.id.home) { |
| finish(); |
| } |
| |
| return super.onOptionsItemSelected(item); |
| } |
| |
| public void getContactsPermission() { |
| // Here, thisActivity is the current activity |
| if (ContextCompat.checkSelfPermission(this, |
| Manifest.permission.READ_CONTACTS) |
| != PackageManager.PERMISSION_GRANTED) { |
| |
| if (ActivityCompat.shouldShowRequestPermissionRationale(this, |
| Manifest.permission.READ_CONTACTS)) { |
| |
| } else { |
| ActivityCompat.requestPermissions(this, |
| new String[]{Manifest.permission.READ_CONTACTS}, |
| 1); |
| } |
| } else { //already granted |
| onContactsPermissionGranted(); |
| } |
| } |
| |
| private void setGroup(String group) { |
| mGroup = group; |
| boolean editable = false; |
| if ("Inbox".equals(group)) { |
| mFab.setImageDrawable(new IconDrawable(this, MaterialIcons.md_reply).color(Color.WHITE)); |
| mFab.setOnClickListener(new View.OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| launchAndCreateMessage(ComposeActivity.this, mMessageRef.getParent(), mFrom.getText(), "myself@email.com", "RE: " + mSubject.getText(), "", null, "Drafts"); |
| } |
| }); |
| |
| } else if ("Drafts".equals(group)) { |
| editable = true; |
| mFab.setImageDrawable(new IconDrawable(this, MaterialIcons.md_send).color(Color.WHITE)); |
| if (mOwner == null || !mOwner.equals(mDeviceId)) { |
| if (mMenu != null) { |
| mMenu.findItem(R.id.action_delete).setVisible(false); |
| } |
| mFab.setOnClickListener(new View.OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| Toast.makeText(ComposeActivity.this, "Can't send message from this device", 0).show(); |
| } |
| }); |
| } else { |
| mFab.setOnClickListener(new View.OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| checkAndSendMessage(); |
| } |
| }); |
| } |
| |
| |
| if (mMenu != null) { |
| mMenu.findItem(R.id.action_attach).setVisible(true); |
| } |
| } else if ("Sent".equals(group)) { |
| mFab.setImageDrawable(new IconDrawable(this, MaterialIcons.md_forward).color(Color.WHITE)); |
| mFab.setOnClickListener(new View.OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| launchAndCreateMessage(ComposeActivity.this, mMessageRef.getParent(), "", "myself@email.com", "FWD: " + mSubject.getText(), mMessage.getText(), null, "Drafts"); |
| } |
| }); |
| if (mMenu != null) { |
| mMenu.findItem(R.id.action_attach).setVisible(true); |
| } |
| } |
| |
| mTo.setEditable(editable); |
| mSubject.setEditable(editable); |
| mMessage.setEditable(editable); |
| } |
| |
| |
| |
| public void setAttachment(final String attachment, final int permission) { |
| this.mAttachment = attachment; |
| this.mAttachmentPermission = permission; |
| if (attachment == null || (permission & PermissionManager.FLAG_READ) != PermissionManager.FLAG_READ) { |
| mAttachmentView.setVisibility(View.GONE); |
| } else { |
| mAttachmentView.setVisibility(View.VISIBLE); |
| mAttachmentView.setOnClickListener(new View.OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| Utils.viewAttachment(ComposeActivity.this, attachment); |
| } |
| }); |
| mAttachmentText.setText(attachment); |
| |
| } |
| } |
| |
| public static void launchAndCreateMessage(Context context, DatabaseReference messagesRef, String to, String from, String subject, String msg, String attachment, String group) { |
| MessageData data = new MessageData(UUID.randomUUID().toString(), to, from, subject, msg, attachment, group); |
| messagesRef.child(data.getId()).setValue(data); |
| Intent intent = new Intent(context, ComposeActivity.class); |
| intent.putExtra(ComposeActivity.EXTRA_MESSAGE_ID, data.getId()); |
| context.startActivity(intent); |
| } |
| |
| private void onContactsPermissionGranted() { |
| ArrayList<String> emailAddressCollection = new ArrayList<String>(); |
| ContentResolver cr = getContentResolver(); |
| Cursor emailCur = cr.query(ContactsContract.CommonDataKinds.Email.CONTENT_URI, null, null, null, null); |
| while (emailCur.moveToNext()) { |
| String email = emailCur.getString(emailCur.getColumnIndex(ContactsContract.CommonDataKinds.Email.DATA)); |
| emailAddressCollection.add(email); |
| } |
| emailCur.close(); |
| String[] emailAddresses = new String[emailAddressCollection.size()]; |
| emailAddressCollection.toArray(emailAddresses); |
| contactAdapter = new ArrayAdapter<String>(this, |
| android.R.layout.simple_dropdown_item_1line, emailAddresses); |
| mTo.setAutoCompleteAdapter(contactAdapter); |
| } |
| |
| @Override |
| public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { |
| super.onRequestPermissionsResult(requestCode, permissions, grantResults); |
| //TODO: generalize to other permissions. Not just contacts |
| if (grantResults.length > 0 |
| && grantResults[0] == PackageManager.PERMISSION_GRANTED) { |
| onContactsPermissionGranted(); |
| } |
| } |
| |
| |
| ArrayList<SyncTextDiff> getSuggestions() { |
| ArrayList<SyncTextDiff> result = new ArrayList<>(); |
| result.addAll(mTo.getSuggestions()); |
| result.addAll(mFrom.getSuggestions()); |
| result.addAll(mSubject.getSuggestions()); |
| result.addAll(mMessage.getSuggestions()); |
| return result; |
| } |
| |
| void checkAndSendMessage() { |
| //TODO: PermissionManager.requestDialog() |
| mPermissionManager.request(mPath + "/send", mDeviceId) |
| .putExtra(PermissionManager.EXTRA_TIMEOUT, "2000") |
| .putExtra(PermissionManager.EXTRA_COLOR, "#F00"); |
| |
| if (getSuggestions().size() > 0) { |
| AlertDialog.Builder builder = new AlertDialog.Builder(this); |
| builder.setMessage("Confirm suggestions before sending message"); |
| builder.setPositiveButton("Confirm", new DialogInterface.OnClickListener() { |
| public void onClick(DialogInterface dialog, int id) { |
| sendMessage(); |
| } |
| }); |
| builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() { |
| public void onClick(DialogInterface dialog, int id) { |
| // User cancelled the dialog |
| } |
| }); |
| |
| AlertDialog dialog = builder.create(); |
| dialog.show(); |
| } else { |
| sendMessage(); |
| } |
| } |
| |
| public void sendMessage() { |
| mMessageRef.child("group").setValue("Sent"); |
| for (String device : targetDevices) { |
| mPermissionService.removeFromConstellation(device); |
| } |
| finish(); |
| } |
| |
| private void deleteMessage() { |
| |
| |
| if ((mPermissionManager.getPermissions(mPath) & PermissionManager.FLAG_WRITE) == PermissionManager.FLAG_WRITE) { |
| mMessageRef.removeValue(); |
| } |
| finish(); |
| |
| } |
| |
| private void pickAttachment() { |
| Intent intent = new Intent(Intent.ACTION_GET_CONTENT); |
| // Uri uri = Uri.parse(Environment.getExternalStorageDirectory().getPath()); |
| intent.setType("*/*"); |
| // intent.setDataAndType(uri, "file/*"); |
| startActivityForResult(Intent.createChooser(intent, "Choose Attachment"), SELECT_ATTACHMENT); |
| } |
| |
| |
| @Override |
| protected void onActivityResult(int requestCode, int resultCode, Intent data) { |
| super.onActivityResult(requestCode, resultCode, data); |
| if (requestCode == DevicePickerActivity.REQUEST_DEVICE_ID && data != null && data.hasExtra(DevicePickerActivity.EXTRA_DEVICE_ID)) { |
| String targetDevice = data.getStringExtra(DevicePickerActivity.EXTRA_DEVICE_ID); |
| |
| if (!mOwner.equals(targetDevice)) { |
| //find most appropriate blessing to extend from |
| mSourceBlessing = mPermissionManager.getBlessing(mOwner, mDeviceId); |
| if (mSourceBlessing == null) { |
| mSourceBlessing = mPermissionManager.getRootBlessing(); |
| } |
| //set default blessings |
| // Blessing deviceBlessing = mSourceBlessing.bless(targetDevice) |
| // .setPermissions(mPath + "/to", PermissionManager.FLAG_SUGGEST) |
| // .setPermissions(mPath + "/subject", PermissionManager.FLAG_SUGGEST) |
| // .setPermissions(mPath + "/message", PermissionManager.FLAG_SUGGEST); |
| addTargetDevice(targetDevice); |
| } |
| |
| JSONObject castArgs = new JSONObject(); |
| try { |
| castArgs.put("activity", ComposeActivity.class.getSimpleName()); |
| castArgs.put(EXTRA_MESSAGE_PATH, mPath); |
| mPermissionService.getMessenger().to(targetDevice).emit("cast", castArgs.toString()); |
| mPermissionService.updateConstellationDevice(targetDevice); |
| |
| } catch (JSONException e) { |
| e.printStackTrace(); |
| } |
| } else if (requestCode == SELECT_ATTACHMENT && resultCode == RESULT_OK) { |
| Uri attachmentUri = data.getData(); |
| // String path = Utils.getRealPathFromURI(this, attachmentUri); |
| String path = Utils.getFileName(this, attachmentUri); |
| // File f = new File(path); |
| Toast.makeText(this, "Attached " + path, 0).show(); |
| mMessageRef.child("attachment").setValue(path); |
| } |
| } |
| |
| public void addTargetDevice(String id) { |
| targetDevices.add(id); |
| for (Map.Entry<String, PermissionedTextLayout> entry : mPermissionedFields.entrySet()) { |
| PermissionedTextLayout edit = entry.getValue(); |
| String key = entry.getKey(); |
| int current = mPublicBlessing.getPermissions(mPath + "/" + key); |
| if ((current & PermissionManager.FLAG_SUGGEST) == PermissionManager.FLAG_SUGGEST) { |
| edit.setAction(1, new IconDrawable(ComposeActivity.this, MaterialIcons.md_cancel) |
| .color(Color.RED) |
| .actionBarSize(), "Toggle Permission"); |
| } else { |
| edit.setAction(1, new IconDrawable(ComposeActivity.this, MaterialIcons.md_cast) |
| .color(Color.BLACK) |
| .actionBarSize(), "Toggle Permission"); |
| } |
| } |
| mAttachmentCast.setVisibility(View.VISIBLE); |
| } |
| |
| public void removeTargetDevice(String id) { |
| targetDevices.remove(id); |
| if (targetDevices.size() == 0) { |
| for (Map.Entry<String, PermissionedTextLayout> entry : mPermissionedFields.entrySet()) { |
| PermissionedTextLayout edit = entry.getValue(); |
| edit.clearActions(); |
| } |
| mAttachmentCast.setVisibility(View.GONE); |
| } |
| } |
| |
| @Override |
| public void onServiceConnected(ComponentName name, IBinder service) { |
| PermissionService.PermissionServiceBinder binder = (PermissionService.PermissionServiceBinder) service; |
| mPermissionService = binder.getInstance(); |
| |
| |
| if (mPermissionService != null) { |
| mPermissionManager = mPermissionService.getPermissionManager(); |
| mDeviceId = mPermissionService.getDeviceId(); |
| |
| Intent intent = getIntent(); |
| if (intent != null) { |
| if (intent.hasExtra(EXTRA_MESSAGE_PATH)) { |
| mPath = intent.getStringExtra(EXTRA_MESSAGE_PATH); |
| String[] pathElements = mPath.split("/"); |
| mId = pathElements[pathElements.length - 1]; |
| } else if (intent.hasExtra(EXTRA_MESSAGE_ID)) { |
| mId = intent.getStringExtra(EXTRA_MESSAGE_ID); |
| mPath = EmailActivity.KEY_DOCUMENTS |
| + "/" + mDeviceId |
| + "/" + EmailActivity.KEY_EMAILS |
| + "/" + EmailActivity.KEY_MESSAGES |
| + "/" + mId; |
| } |
| } |
| |
| if (mPath == null) { |
| mId = UUID.randomUUID().toString(); |
| mPath = "documents/" + mDeviceId + "/emails/messages/" + mId; |
| } |
| |
| //parse path to get owner |
| String[] pathElements = mPath.split("/"); |
| if (pathElements != null && pathElements.length > 1) { |
| mOwner = pathElements[1]; |
| } |
| |
| if (mMenu != null && !mOwner.equals(mDeviceId)) { |
| mMenu.findItem(R.id.action_attach).setVisible(false); |
| mMenu.findItem(R.id.action_delete).setVisible(false); |
| } |
| |
| mMessageRef = mPermissionService.getFirebaseDB().getReference(mPath); |
| mSyncedMessageRef = mPermissionService.getFirebaseDB().getReference("documents/" + mOwner + "/emails/syncedMessages/" + mId); |
| mPermissionManager.addPermissionEventListener(mPath, messagePermissionListener); |
| |
| mMessageRef.child("group").addValueEventListener(groupListener); |
| |
| mMessageRef.child("attachment").addValueEventListener(attachmentListener); |
| mPermissionManager.addPermissionEventListener(mPath + "/attachment", attachmentPermissionListner); |
| |
| initField(mTo, "to"); |
| initField(mFrom, "from"); |
| initField(mSubject, "subject"); |
| initField(mMessage, "message"); |
| |
| mPublicBlessing = mPermissionManager.bless("public"); |
| // .setPermissions(mPath + "/subject", PermissionManager.FLAG_READ); |
| |
| mPermissionManager.addOnRequestListener("documents/" + mDeviceId + "/emails/messages/" + mId + "/*", new PermissionManager.OnRequestListener() { |
| @Override |
| public boolean onRequest(PermissionRequest request, Blessing blessing) { |
| mRequests.put(request.getPath(), request); |
| return true; |
| } |
| |
| @Override |
| public void onRequestRemoved(PermissionRequest request, Blessing blessing) { |
| |
| } |
| }); |
| mPermissionService.setStatus(EXTRA_MESSAGE_PATH, mPath); |
| |
| mPermissionService.addDiscoveryListener(new PermissionService.DiscoveryListener() { |
| @Override |
| public void onChange(Map<String, DeviceData> devices) { |
| |
| } |
| |
| @Override |
| public void onDisassociate(String deviceId) { |
| if (deviceId.equals(mOwner)) { |
| finish(); |
| }else{ |
| removeTargetDevice(deviceId); |
| } |
| } |
| }); |
| } |
| } |
| |
| PermissionManager.OnPermissionChangeListener attachmentPermissionListner = new PermissionManager.OnPermissionChangeListener() { |
| @Override |
| public void onPermissionChange(int current) { |
| setAttachment(mAttachment, current); |
| } |
| |
| @Override |
| public void onCancelled(DatabaseError databaseError) { |
| |
| } |
| }; |
| |
| |
| ValueEventListener groupListener = new ValueEventListener() { |
| @Override |
| public void onDataChange(DataSnapshot dataSnapshot) { |
| if (dataSnapshot.exists()) { |
| String newGroup = dataSnapshot.getValue(String.class); |
| setGroup(newGroup); |
| } |
| } |
| |
| @Override |
| public void onCancelled(DatabaseError databaseError) { |
| |
| } |
| }; |
| |
| ValueEventListener attachmentListener = new ValueEventListener() { |
| @Override |
| public void onDataChange(DataSnapshot dataSnapshot) { |
| if (dataSnapshot.exists()) { |
| String newAttachment = dataSnapshot.getValue(String.class); |
| setAttachment(newAttachment, mAttachmentPermission); |
| } |
| } |
| |
| @Override |
| public void onCancelled(DatabaseError databaseError) { |
| |
| } |
| }; |
| |
| PermissionManager.OnPermissionChangeListener messagePermissionListener = new PermissionManager.OnPermissionChangeListener() { |
| @Override |
| public void onPermissionChange(int current) { |
| if (current > 0) { |
| mMessageRef.child("id").setValue(mId); |
| } |
| } |
| |
| @Override |
| public void onCancelled(DatabaseError databaseError) { |
| |
| } |
| }; |
| |
| |
| @Override |
| public void onServiceDisconnected(ComponentName name) { |
| |
| } |
| |
| void initField(final PermissionedTextLayout edit, final String key) { |
| edit.setSyncText(new SyncText(mDeviceId, PermissionManager.FLAG_SUGGEST, mSyncedMessageRef.child(key), mMessageRef.child(key))); |
| edit.setPermissionedTextListener(new PermissionedTextLayout.PermissionedTextListener() { |
| @Override |
| public void onSelected(final SyncTextDiff diff, PermissionedTextLayout text) { |
| int current = mPermissionManager.getPermissions(mPath + "/" + key); |
| if ((current & PermissionManager.FLAG_WRITE) == PermissionManager.FLAG_WRITE) { |
| Intent content = new Intent(ComposeActivity.this, ComposeActivity.class); |
| content.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP); |
| String name = diff.getSource(); |
| if(mPermissionService.getDiscovered().containsKey(name)){ |
| name = mPermissionService.getDiscovered().get(diff.source).getName(); |
| } |
| mPermissionService.requestDialog(diff.source, "Apply changes from " + name, "be vigilant", |
| new PermissionService.ActionCallback() { |
| @Override |
| public boolean onAction(Intent intent) { |
| acceptSuggestions(diff.source); |
| return true; |
| } |
| }, new PermissionService.ActionCallback() { |
| @Override |
| public boolean onAction(Intent intent) { |
| rejectSuggestions(diff.source); |
| return true; |
| } |
| }, content); |
| } |
| } |
| |
| @Override |
| public void onAction(int action, PermissionedTextLayout text) { |
| if (action == 1) { |
| if (mPublicBlessing != null) { |
| int current = mPublicBlessing.getPermissions(mPath + "/" + key); |
| if ((current & PermissionManager.FLAG_SUGGEST) == PermissionManager.FLAG_SUGGEST) { |
| mPublicBlessing.setPermissions(mPath + "/" + key, current & ~PermissionManager.FLAG_SUGGEST); |
| text.setAction(1, new IconDrawable(ComposeActivity.this, MaterialIcons.md_cast) |
| .color(Color.BLACK) |
| .actionBarSize(), "Toggle Permission"); |
| } else { |
| mPublicBlessing.setPermissions(mPath + "/" + key, current | PermissionManager.FLAG_SUGGEST); |
| text.setAction(1, new IconDrawable(ComposeActivity.this, MaterialIcons.md_cancel) |
| .color(Color.RED) |
| .actionBarSize(), "Toggle Permission"); |
| } |
| } |
| } else if (action == 2) { |
| mPermissionManager.request(mPath + "/to", mDeviceId) |
| .setPermissions(PermissionManager.FLAG_WRITE) |
| .udpate(); |
| } |
| } |
| }); |
| |
| mPermissionedFields.put(key, edit); |
| final String path = "documents/" + mDeviceId + "/emails/messages/" + mId + "/" + key; |
| |
| mPermissionManager.addPermissionEventListener(mPath + "/" + key, new PermissionManager.OnPermissionChangeListener() { |
| @Override |
| public void onPermissionChange(int current) { |
| edit.onPermissionChange(current); |
| |
| //TODO:generalize the following request button |
| if ("to".equals(key)) { |
| if (current == PermissionManager.FLAG_READ) { |
| edit.setAction(2, new IconDrawable(ComposeActivity.this, MaterialIcons.md_vpn_key), "Request Permission"); |
| } else { |
| edit.removeAction(2); |
| } |
| |
| if ((current & PermissionManager.FLAG_WRITE) == PermissionManager.FLAG_WRITE) { |
| edit.setAutoCompleteAdapter(contactAdapter); |
| } else { |
| edit.setAutoCompleteAdapter(null); |
| } |
| } |
| } |
| |
| @Override |
| public void onCancelled(DatabaseError databaseError) { |
| |
| } |
| }); |
| } |
| |
| public void acceptSuggestions(String src) { |
| for (PermissionedTextLayout text : mPermissionedFields.values()) { |
| text.acceptSuggestions(src); |
| } |
| } |
| |
| public void rejectSuggestions(String src) { |
| for (PermissionedTextLayout text : mPermissionedFields.values()) { |
| text.rejectSuggestions(src); |
| } |
| } |
| |
| public void unlink() { |
| for (PermissionedTextLayout text : mPermissionedFields.values()) { |
| text.unlink(); |
| } |
| mMessageRef.child("attachment").removeEventListener(attachmentListener); |
| mMessageRef.child("group").removeEventListener(groupListener); |
| if (mPermissionService != null) { |
| if (mPublicBlessing != null) { |
| mPublicBlessing.revokePermissions(mPath); |
| } |
| |
| //cancel all requests made from this activity |
| mPermissionManager.cancelRequests(mDeviceId + mId); |
| } |
| |
| unbindService(this); |
| } |
| |
| @Override |
| protected void onDestroy() { |
| super.onDestroy(); |
| unlink(); |
| } |
| } |
