Utilities Easy Feedback Form: Bug reports and player feedback sent to Trello

Get Easy Feedback on the Asset Store!
Current Version 3.1.0

What is Easy Feedback?
Easy Feedback streamlines bug reporting and player feedback in Unity games by bringing it directly to developers.

Detailed feedback and bug reports are sent from in-game to Trello, where these they are easily accessible, read, and organized.

How does it work?
When a player submits a report, it is categorized and directed to a list in the developer's Trello board based on the type of feedback. Included along with the report is a screenshot taken the instant the Feedback Form is opened, system information (OS, CPU, GPU, etc.), quality settings (resolution, quality level, etc), and a log of all messages, warnings and exceptions since the last report.

All of this information is formatted with markdown on Trello for easy reading.

Current features

• Bug reports and feedback sent directly to Trello
• One-click Trello setup without leaving the Unity editor
• Reports automatically categorized and organized
• Highly customizable UI
• Categories in form derived from lists on Trello
• Tagging by bug priority level
• Detailed reports including:
  • Screenshot
  • Debug log and exceptions
  • Stack trace
  • System information (OS, CPU, GPU, etc.)
  • Unity player information (resolution, quality level, etc.)
• API for adding custom game-specific information to the report
• Ability to add multiple file attachments to the report
• Callbacks for form opened, closed, and submitted
• Modular system allowing custom fields to be added to the form
• Customizable feedback key and message
• Store reports locally (Expo Mode)

Easy Feedback in action
I've been working closely with Twitch streamer QaziTV to get feedback and live testing of the asset while he develops his latest game. Here are some screenshots from his game, and his feedback board in Trello:

In-game


Example report


In Trello


Easy Feedback in Unity
I've put a considerable amount of time into trying to streamline authentication and setup with the Trello API in Unity. From the beginning, the goal was to be able to authenticate, create a new board, or select an existing one for feedback all in the editor. Eventually, I'd also like developers to be able to customize their boards (adding categories and tags) from within the editor, but this is not currently supported.

Easy Feedback in inspector when first added to the scene


Trello authentication


After authentication


Creating a new feedback board


Selecting a feedback board


Thanks for reading! I'd love to hear your questions, thoughts, and feedback!

 

Including custom information in your feedback
This next couple weeks, I’m focusing on making Easy Feedback more modular so developers can write scripts adding their own functionality to the feedback form. In the next couple weeks, I’m working on adding the following features:

• UnityEvents for registering callback functions when the form is opened, submitted, and closed.
• Ability to append/modify information sent with the report
• Modular system for adding fields to the feedback form

With the latest update, I’ve crossed off the second bullet on that list by exposing the report data publicly from the feedback form script. With the aid of some helper methods, developers can modify existing information sent with the report, and add their own sections to the report.

The feature is currently a bit rough, but the goal is to expose a simple barebones API, and add features as use cases crop up in early access.

 

OnFormOpened, OnFormSubmitted, and OnFormClosed callbacks
Until now, developers have just been modifying the FeedbackForm script directly to add their custom feedback code. This was pretty unsustainable, as every time they updated the asset, it'd break their changes! This week's update addresses that, adding 3 UnityEvents to the FeedbackForm script: OnFormOpened, OnFormSubmitted, and OnFormClosed.



Honestly, I should have added these sooner, as I've gotten some reports from developers that they had not been updating the asset with weekly builds because they didn't want their form to break, and to have to rewrite it. Hopefully this will help mitigate the fear of updating for the future.

Here's exactly when each event is invoked:

OnFormOpened: This event is invoked right after the screenshot is taken, and right before the form appears on the screen. Any information that must be collected when the user begins to submit a report should be collected here.

OnFormSubmitted: This event is invoked right before the report is sent to Trello, after the user clicks the "submit" button. This would be a good time to add information from custom fields on the form to the report.

OnFormClosed: This event is called whenever the form closes, whether a report was submitted or not. This is a good time to reset any custom fields on the form, or clean up any temporary resources created for the report (this is where the screenshot taken with the form is deleted!).

These core three events will not be changing much during the rest of the alpha, so developers rest assured that you can hook in your scripts without the next update breaking your form.

GDC 2017
Next week I'll be attending the Game Developers Conference, so there will not be an update for Easy Feedback. However, I will be writing up a more technical devlog post on how the WebView for Trello authentication works, so keep your eye out for that! If you are attending GDC and would like to meet up and chat, reach out to me on Twitter! I'll be handing out Easy Feedback discount keys, so be sure to nab one!

 

In lieu of an update this week, I'd like to talk in depth about one of the more technically challenging parts of Easy Feedback: in-editor authentication via WebView.

Before launching early access, Easy Feedback was in somewhat of a "closed beta" state. I had given the asset to fellow game developer and streamer, Qazi, to use in his latest game, Shotgun Farmers. At that time, the only way to authenticate with Trello was to navigate to the API homepage in a browser, and request an application key and secret. Qazi then had to edit a script that held the Trello API key and secret as constant strings (aptly named TrelloAPIConfig), adding his key and secret. This was all a holdover from when the feedback form was originally written for my game, Noah and The Quest to Turn on The Light. At the time, I hadn't planned to release the form as a standalone asset, so I didn't put much thought into reuse.

Before launching the public alpha, one of the first priorities was abstracting users away from the Trello API as much as possible. Ideally, I wanted to keep the users within the editor at all times. With a constant application key for all of Easy Feedback, I can direct users to a URL where they will be required to log in and give Easy Feedback permission to access their account. After they give permission, users are given a single token that they can copy and paste into the Easy Feedback script. Easy enough, now we just need to show all that in the editor.

This is where things get tricky. The WebView API (as seen in action in the Asset Store window), is not publicly accessible. In fact, it's an internal sealed class, and there's no documentation on it at all. But, I was determined. If the Asset Store could display web content, I sure could too. Accessing non-public types, methods, and fields in C# isn't impossible, but it's also not easy.

Thanks to reflection, if I expect a type, method, or field to exist, I can find it, execute it, or access and modify it, whether public, private, sealed, or internal. The downside to this technique is that I have to know the exact definition of the type ahead of time, and any mistakes result in frustratingly vague runtime exceptions. This is where Matt Rix's Unity Decompiled repository came in very handy. Not could I reference the full definition of the WebView class, but I could also reference the AssetStoreWindow class to figure out how to properly use WebView.

With all that covered, let's talk about how the authentication window implementation works.

Initializing the EditorWindow
When the window is first initialized, we have to do a few things:

First, we get the HostView for the window. This is a private field in EditorWindow, named "m_Parent." We'll need this later, when initializing the WebView.

FieldInfo parentInfo = typeof(WebWindow).GetField("m_Parent", ALL_FLAGS);
guiViewParent = parentInfo.GetValue(this);

Next, we search the application assemblies for the WebView and GUIClip types. Finding the types is pretty simple, we just search through each assembly in the current application domain until we find a type that matches a given string name, then return that type.

Code (CSharp):

1. private Type getTypeFromAssemblies(string typeName)
2. {
3.    Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
4.    foreach (Assembly assembly in assemblies)
5.    {
6.        Type[] types = assembly.GetTypes();
7.        foreach (Type type in types)
8.        {
9.            if (type.Name.Equals(typeName, StringComparison.CurrentCultureIgnoreCase)
10.                || type.Name.Contains('+' + typeName))
11.                return type;
12.        }
13.    }
14.    Debug.LogWarning("Could not find type \"" + typeName + "\" in assemblies.");
15.    return null;
16. }

We only need the static "Unclip" function from GUIClip, so we go ahead and reflect out the method information from the type. We pass in the Rect type when calling GetMethod on the type, as GUIClip contains multiple definitions for Unclip, and we want the one that returns a Rect.

Code (CSharp):

1. // get GUIClip.Unclip
2. unclipMethod = guiClipType.GetMethod("Unclip", new[] { typeof(Rect) });

Initializing the WebView
Disclaimer: because of the lack of documentation, all the code from here on out is the result of heavy reference of AssetStoreWindow, and a lot of trial and error. I make no promises that this is the correct, most efficient, or even most stable way to render a WebView. By continuing, the reader assumes all liability for all emotional and physical damage as a result of reading past this point.

Code (CSharp):

1. private void initWebView()
2. {
3.    // dispose and destroy webView
4.    if ((ScriptableObject)webView)
5.    {
6.        DestroyImmediate((ScriptableObject)webView);
7.        webView = null;
8.    }
9.    // create the webview
10.    webView = ScriptableObject.CreateInstance(webViewType);
11.    webViewType.GetMethod("InitWebView").Invoke(webView,
12.        new object[] { guiViewParent, (int)position.x, (int)position.y, (int)position.width, (int)position.height, false });
13.    // load url
14.    webViewType.GetMethod("SetDelegateObject").Invoke(webView, new object[] { this });
15.    loadURLMethod = webViewType.GetMethod("LoadURL");
16.    loadURLMethod.Invoke(webView, new object[] { URL });
17.    // get methods from webview
18.    showMethod = webViewType.GetMethod("Show");
19.    setFocusMethod = webViewType.GetMethod("SetFocus");
20.    setSizeAndPositionMethod = webViewType.GetMethod("SetSizeAndPosition");
21.    reloadMethod = webViewType.GetMethod("Reload");
22.    executeJSMethod = webViewType.GetMethod("ExecuteJavascript");
23. }

First, we check if we already have a reference to an existing WebView object. If so, we destroy it so that we can initialize a new one. Next, we instantiate the WebView with ScriptableObject.CreateInstance, and invoke the InitWebView function on our newly created object. This is a good time to talk about why Unity Decompiled is so helpful: When using reflection to invoke a method on an object, you need to know the method's full signature. All parameters are passed in as an array of objects that must all be present, of the correct type and in the correct order, or the runtime gods will smite you with incredibly unhelpful exceptions or editor crashes. Referencing Unity Decompiled is the only tool we have to fight the runtime gods. This is where we pass in the GUIView we retrieved in init.

Code (CSharp):

1. // create the webview
2. webView = ScriptableObject.CreateInstance(webViewType);
3. webViewType.GetMethod("InitWebView").Invoke(webView,
4.    new object[] { guiViewParent, (int)position.x, (int)position.y, (int)position.width, (int)position.height, false });

Next, we invoke the SetDelegateObject method on the WebView, and pass in the current EditorWindow instance. Then, we reflect out the LoadURL method, invoke it with the current URL as the only parameter, and save the method info for later use.

Code (CSharp):

1. // load url
2. webViewType.GetMethod("SetDelegateObject").Invoke(webView, new object[] { this });
3. loadURLMethod = webViewType.GetMethod("LoadURL");
4. loadURLMethod.Invoke(webView, new object[] { URL });

Finally, we reflect some helpful methods out of WebView, and save them for future use. For each of the methods, we'll also write helpful wrapper methods for quick and clean invocation.

Code (CSharp):

1. // get methods from webview
2. showMethod = webViewType.GetMethod("Show");
3. setFocusMethod = webViewType.GetMethod("SetFocus");
4. setSizeAndPositionMethod = webViewType.GetMethod("SetSizeAndPosition");
5. reloadMethod = webViewType.GetMethod("Reload");
6. executeJSMethod = webViewType.GetMethod("ExecuteJavascript");

Rendering the WebView
If you thought we were flying pretty loose and wild before, strap in.

Code (CSharp):

1. private void OnGUI()
2. {
3.    if (unclipMethod != null)
4.    {
5.        webViewRect = (Rect)unclipMethod.Invoke(null, new object[]
6.        {
7.            new Rect(0f, 0f, base.position.width, base.position.height)
8.        });
9.    }
10.    else
11.    {
12.        init();
13.    }
14.    //Rect webViewRect = new Rect(0f, 0f, base.position.width, base.position.height);
15.    if (webView == null)
16.    {
17.        init();
18.    }
19.    else if (Event.current.type == EventType.Repaint)
20.    {
21.        try
22.        {
23.            //doGUIMethod.Invoke(webView, new object[] { webViewRect });
24.            setSizeAndPositionMethod.Invoke(webView, new object[]
25.            {
26.                (int)webViewRect.x,
27.                (int)webViewRect.y,
28.                (int)webViewRect.width,
29.                (int)webViewRect.height
30.            });
31.            // set white background
32.            executeJS("if(document.getElementsByTagName('body')[0].style.backgroundColor === '') { document.getElementsByTagName('body')[0].style.backgroundColor = 'white'; }");
33.        }
34.        catch (TargetInvocationException e)
35.        {
36.            // web view was disposed, but not by us :(
37.            webView = null;
38.            DestroyImmediate(this);
39.        }
40.    }
41. }

I'd like to address a reoccurring trend in this block. Sometimes, OnGUI may be called before init, or references may be cleaned up by some mysterious outside force. To counter this, we take care to check that things are not null before trying to use them. If they are we just initialize the window again.

The first thing we do in OnGUI is invoke the Unclip method we retrieved in init. To be completely honest, I'm not completely sure what this does. But the Asset Store window does it, and it works.

Code (CSharp):

1. if (unclipMethod != null)
2. {
3.    webViewRect = (Rect)unclipMethod.Invoke(null, new object[]
4.    {
5.        new Rect(0f, 0f, base.position.width, base.position.height)
6.    });
7. }
8. else
9. {
10.    init();
11. }

If this call to OnGUI is the repaint pass, we attempt to Invoke SetSizeAndPosition on the WebView, setting it to the size and position of the current editor window. Sometimes, our WebView object may still end up null here. In that case, we just go ahead and kill the window. This was more of an issue in development, and I haven't been able to reproduce it, but I'd rather be safe than sorry.

Code (CSharp):

1. if (webView == null)
2. {
3.    init();
4. }
5. else if (Event.current.type == EventType.Repaint)
6. {
7.    try
8.    {
9.        //doGUIMethod.Invoke(webView, new object[] { webViewRect });
10.        setSizeAndPositionMethod.Invoke(webView, new object[]
11.        {
12.            (int)webViewRect.x,
13.            (int)webViewRect.y,
14.            (int)webViewRect.width,
15.            (int)webViewRect.height
16.        });
17.        // set white background
18.        executeJS("if(document.getElementsByTagName('body')[0].style.backgroundColor === '') { document.getElementsByTagName('body')[0].style.backgroundColor = 'white'; }");
19.    }
20.    catch (TargetInvocationException e)
21.    {
22.        // web view was disposed, but not by us :(
23.        webView = null;
24.        DestroyImmediate(this);
25.    }
26. }

An extra fun feature of the WebView is that any webpage without a defined background color will render with a transparent background. This isn't an issue of course, because the Trello API pages all define a background color, right?



Heck.

From what I can tell, the WebView mostly takes over and handles rendering within its delegate editor window on its own, and simply rendering a blank white texture in the background doesn't work. Great.

But, it's 2017, and no web problem is solved in 2017 without JavaScript. Luckily for us, WebView has an ExecuteJS method lying around. We call our wrapper function, and execute JavaScript that sets the page's background as white if it does not already have a defined background color. We do this on every OnGUI call.

Excuse me, I need a moment.

Code (CSharp):

1. // set white background
2. executeJS("if(document.getElementsByTagName('body')[0].style.backgroundColor === '') { document.getElementsByTagName('body')[0].style.backgroundColor = 'white'; }");

OnFocus and OnLostFocus
Whenever the window gains or loses focus, we invoke the SetFocus method on the WebView, and pass in the focus state as a bool. If the window is currently being focused, we also invoke SetHostView on the WebView and pass in the editor window's GUIView, then invoke the Show method on the WebView. Again, the Asset Store does this, so we're doing it.

Code (CSharp):

1. private void OnFocus()
2. {
3.    setFocus(true);
4. }
5. private void OnLostFocus()
6. {
7.    setFocus(false);
8. }
9. private void setFocus(bool focus)
10. {
11.    if (webView != null)
12.    {
13.        try
14.        {
15.            if (focus)
16.            {
17.                webViewType.GetMethod("SetHostView").Invoke(webView, new object[] { guiViewParent });
18.                showMethod.Invoke(webView, null);
19.            }
20.            setFocusMethod.Invoke(webView, new object[] { focus });
21.        }
22.        catch (TargetInvocationException e)
23.        {
24.            // web view was disposed before we expected it :(
25.            webView = null;
26.            DestroyImmediate(this);
27.        }
28.    }
29. }

OnDestroy
Don't worry, this is all almost over. Finally, when the editor window is destroyed, we invoke DestroyWebView on the WebWindow.

Code (CSharp):

1. private void OnDestroy()
2. {
3.    // destroy web view
4.    if (webView != null)
5.    {
6.        webViewType.GetMethod("DestroyWebView", ALL_FLAGS).Invoke(webView, null);
7.        webView = null;
8.    }
9. }

Final thoughts
If you enjoy the Unity Editor crashing every time your scripts recompile being a primary element of your debugging workflow, I highly recommend trying out implementing an undocumented internal API.

There's a lot of mess and inefficiency in this script, but it's functional for the time being, and the end result really does improve the authentication flow. When I have more core features implemented, I'll be coming back and cleaning things up before full release.

 

This looks really cool! Followed

 

This looks awesome!

We will be purchasing the early access - Do you support file attachments? So if we wanted to get a save file from a directory and include it with the screenshot, is that supported or planned?

Thank you!

 

Multiple file attachments are currently planned, and should be available in the early access before the end of the month.

The latest update, 0.6.0, exposes a field for a single file attachment to be sent with the current report. By default, this is the screenshot, but it can be replaced with another file.

 

Custom feedback categories
Last week, Easy Feedback 0.7.0 was released to early access developers. With this release, developers can now define custom feedback categories, derived from lists on their Trello board.

Previously, reports were categorized into two predefined categories, "Feedback" and "Bugs." All feedback boards required respective lists for both categories, and the lists could not be removed or renamed.

However, users can now define any number of categories with any name they wish. Any list with the text "(EF)" at the end of its name is a valid feedback category, and will added to the categories dropdown on the form. The name of the category on the form is derived from the name of its respective list.

Custom categories in action


Here I have a new board on Trello. I have created two feedback categories named, "My Category" and "My Other Category." I've also added a third non-category list.



When I load the new board from my Trello account in the editor, the categories are found on the board, and added to the categories dropdown on the form.



In-game, I can select my categories from the dropdown when submitting a report. Let's go ahead and label this report as "My Category."



After I submit my report, it appears under the "My Category" list!

 

Last update to Early Access before release!
Easy Feedback has come a long way since the project started late last year, mostly thanks to the support of the pioneering Early Access developers who supported development not only by paying for an incomplete product, but in their amazing feedback and bug reports (many of which were often fixed by the developer before I could even reply to the post!). I really appreciate the overwhelming support during development.

With that, I'm happy to announce that the latest update, 1.0.0b1, is the last major update to Easy Feedback before official release on itch.io and the Unity Asset Store.

After getting the last round of bug reports from Early Access developers, I'll be sending the asset off for approval and listing on the Asset Store. Right now, we're looking at an early May release.

If you'd like information on the release as we get closer to May, consider signing up for the Easy Feedback mailing list!

 

Easy Feedback is now available on itch and the Unity Asset Store!
Easy Feedback has now been officially released on itch and the Unity Asset Store!

A huge thanks to all of the early access developers who gave incredible and invaluable feedback during the development process. Easy Feedback wouldn't be as great as it is today without them.

 

1.0.4 Changelog
I've been posting these mostly over on the itch forums for Easy Feedback, but I'm going be sure to post a changelog here as well in the future.

Minor

• Fix issue with "Get Trello API Token" focusing Unity cloud services windows instead of opening authentication window

 

1.0.5 Changelog
Minor

• Replace Application.CaptureScreenshot with ScreenCapture.CaptureScreenshot for Unity 2017

 

1.1.0 Changelog
Major

• Add Markdown formatting helper class

 

1.1.1 Changelog
Minor

• Update Unity API references for Unity 2017.3

 

1.1.2 Changelog
Minor

• Use in-editor web window for Trello authentication in Unity 2017
• Improve Trello API request timeout handling

 

Looking good! I'm curious which security measures you have implemented - if a team uses trello as a project management platform, it would be a rather severe risk if outsiders get access to all trello boards. That is especially true if business-related data is shared/linked on trello. I realize that at least loss of data can be somewhat mitigated by exporting to file with trello business, but unauthorized access of business data is not solved by that. You could argue that one should not store or even link sensitive data on trello in the first place, but I'm wondering whether all boards could be gained access to by decompiling (which is rather easy with C#) to access the token.

 

Any chance you can add "screenshot drawings" so that the user can scribble/draw on a screenshot if required?

 

Sorry for the late response!

As far as I know, there's no way to limit the scope of tokens to one board for the Trello API, so the Easy Feedback token will have full read/write access to all boards on the account. The token is not stored in C#, so it's not quite as easy as just decompiling, but it is distributed with the game (not going into how for obvious reasons ), so it is possible that a user could gain access to the token and use it for malicious reasons. In the setup instructions, I explicitly advise creating a Trello account just for Easy Feedback because of this.

The best solution I've come up with to circumvent this is to host a middleware API that acts as a one board write-only bridge between distributions and Trello. However, hosting the service isn't cost effective for me without charging hosting and maintenance fees. If for some reason you need this service, please reach out to me privately and we can arrange something.

 

This is a super interesting idea! I'll definitely look into it.

 

wow all of it is really exciting and well made.

 

Great to hear!

I also agree with the scribbling suggestion. Another thing I've been looking into is hooking this up with Chman's gif recording solution. I haven't really delved into it, but my general idea was to add a button to the feedback form that prompts the gif recording to start (wouldn't want to have it running constantly) and to stop next time the form is re-opened. I'll keep you guys updated on how it works out once I get around to it.

By the way, this asset really is a breeze to get going and does exactly what it should. Great job!

 

That sounds really neat! It should be pretty easy to hook up with Report.AttachFile. If you need any help setting it up, please let me know!

Glad to hear it! If you haven't already, please consider giving it a written review on the asset page. Those go a super long way for visibility.

 

1.1.3 Changelog

• Fixed Trello API request certificates failing to authenticate in editor

 

Passing on a suggestion I've been getting from a customer of mine: Generally, from a user perspective, you'd expect to click submit, maybe see a popup message 'your feedback is now being sent!" as a confirmation and then be done with it. After dismissing the 'Sending feedback...' dialogue, you wouldn't want a popup once the transmission is complete (that'd usually interfere with what the user is doing at that time.)
In fact, you'd want things to run in the background, maybe with a small 'submitting feedback" indicator somewhere in a corner. Another issue that they have encountered is that for some reason, sending failed and their feedback was lost. Wouldn't it make more sense to retry sending periodically?

 

This is a good suggestion! I'll look into better submission UX for future updates. I should also probably make it a bit easier to extend or override the default submission UI flow, to make it a bit easier for y'all to tailor things to your specific application.

Yeah, EF should definitely attempt to retry if the submission fails. I'm currently working on an overhaul of the web request and API code, so I can roll that stuff in with that update.

 

Which platforms does this asset support ? Like Android, IOS, Standalone ...

 

Easy Feedback should support all platforms Unity builds to, although I don't believe it's been tested on Xbox or Switch. I know of some PS4 and iOS developers using it, but I haven't tested on those platforms directly. I have tested on Android and macOS/PC/Linux Standalone, as well as WebGL. If you have any issues with any platform, please feel free to reach out to me via email or on the support forums. It's my goal to support as many platforms as possible.

 

Just an update on this one: I've been using Easy Feedback in my own game on iOS and Android, and I can confirm that it works great on both platforms!

 

1.1.4 Changelog

• Fix editor bug causing "Invalid editor window" errors. You may need to reset your editor layout in Window > Layouts to get the message to disappear in existing projects
• Fix bug preventing form from opening on Android

 

1.1.5 Changelog

• Fix compilation error in 2017.2+

 

Just purchased this and it added readily, but it does not keep cursor focus when the form is up. I need to hit escape to regain the mouse and then position it on the form. In some cases the form disappears and then a new F12 is needed to bring it back. Any idea what is going on? Thank you!

 

I pinged the author of this asset directly via e-mail and did not receive a response. It is starting to look like it is abandoned. That's unfortunate as it seems to mostly work. Without clearing up the mouse issues though I can't use it. $16.

 

Hey! Sorry for the silence.

Just wanted to clarify here that we have been corresponding via email. Unfortunately, the timing of the original email was a bit bad, because I was out of town for GDC, and I was later than usual to respond. Easy Feedback is not abandoned, and I'm still providing support for the asset. In the case above, I believe it is a conflict with a FPS controller asset the dev is using, as it sounds like standard FPS behavior, and is the first time I've heard of the mouse disappearing.

 

1.2.0 Changelog

• Add support for the Plugins folder (and use it by default)
• Minor bug fixes

(It looks like I forgot to post this changelog at the time of release, I'm posting it now for posterity)

 

1.3.0 Changelog

• Move config menu option to Tools/Easy Feedback/Configure
• Better support for Unity 2019+
• Minor bug fixes

 

This is a great tool! We just upgraded our project from 2018 to 2019.2....what kind of better support is in this last patch? (We've edited the code some so don't want to upgrade the tool unless it's necessary.)

 

There were some deprecated APIs that were still being referenced and caused warnings in the Editor and builds. Nothing major!

 

Easy Feedback is 50% off right now in the Cyber Week Mega Sale! Grab it on sale before this Friday, December 13th! ​

 

1.3.1 Changelog

• Fix IOException error sometimes occurring on form open

 

1.4.0 Changelog

• Add TextMeshPro support
• Fix warnings in console on import

 

1.4.1 Changelog

• Fix form not showing up in editor when build target is Android/iOS

 

First of all, thanks for the awesome asset, it really helpful during our alpha testing period.

There is one question though, is there anyway we can make our customer service filter cards easier?

We can't really rely on player would spend the time to actually select the labels for us, thus we plan to add labels WHEN player is submitting error report and the selected labels will be added to the card based on our logic ( whether it is happening during battle, in town or shopping in merchant ).

Just wanna ask if this is achievable and if it is, can assist me on how to do it?

 

Sorry for the late reply! Notification emails for Unity Forums don't seem to be working for me. :/

This is totally possible with a Custom Form Field. You can take a look at the

PriorityDropdown.cs

script to get an idea of how to work with labels on your report. Label behavior is also documented here and here.

Please let me know if you need any more help!

 

Hi, thanks for the reply. We kinda figure a way to do by adding another labels field in Easy Feedback form so that it can append multiple labels instead of only one ( which is sadly easy feedback form current limitation), then our customer service able to filter it using these labels (current-game-version, build-channel, game-mode and etc)

Custom Form Field does helps, just that we still need to filter via search box which is still not a great way to be honest.

Hopefully you will consider support multiple labels in the future so we don't hav to hack it on our ends. Thanks.

 

Aha, I see now! Thanks for providing more detail. Easy Feedback should absolutely support custom labels. I'll make sure it gets added to the next release.

 

Hey there, this asset looks great! One problem though: the documentation directs me to go to [Edit -> Project Settings -> Easy Feedback Form] to set it up, but there's no entry in Project Settings for the asset:



The asset is installed in Plugins; you can see that the Rainbow Folders asset (also installed in Plugins) has an entry in Project Settings. I have no build errors or other obvious issues that would keep the asset from working. Any idea what's going on?

EDIT: figured it out, the configuration UI is under Tools -> Easy Feedback now. You might want to update your documentation

 

Good catch, thanks!

 

1.5.0 Changelog

• Support multiple labels on report
• Minor bug fixes and changes

 

Just purchased and really cool asset, I have 2 suggestions to make :

1. Please allow us to configure/use our own pre-existing Trello board, managing 2 boards (one main board for the project and another just for EasyFeedback) creates annoyance to keep switching between them.
2. (Optional) Optional field in form for user's email ID so we can capture the mail and inform the user once a bug is fixed/app updated. I can probably do this one myself but its a good feature and probably useful for a lot others too.

 

While it would be possible to support mixed-use boards, it is currently not planned. Until the Trello API provides more restricted scopes for API keys it is too much of a security risk. Please see the warnings on the Trello API documentation and the Easy Feedback getting started guide for more information.

That said, you may be able to use a tool like IFTTT or Trello's Butler to copy or link cards from your feedback board into your main board.

This is a great feature suggestion and something our team already uses internally! I'll look into adding a default email field with the next update. Thanks!