watchOS Objective C Documentation

1. Register with Finotes using the 'Get Started' button in https://finotes.com and login to dashboard.
2. Use "Add App" to link watchOS application to Finotes.
3. Integrate Finotes framework to your application.
4. Test your integration.

Step One

You need to add cocoa pods to your project. You can find more information here

Step Two

pod 'FinotesWatchosCore', '3.0.0'

pod 'FinotesWatchosCore', '3.0.0', :configuration => ['Release']
pod 'FinotesWatchosDebug', '3.0.0', :configuration => ['Debug']

The –repo-update option should be used the first time pod install is run from terminal.

Then install the same by executing the following command from terminal where your Podfile resides.
Here the —repo-update is added incase your local cocoa pods repository is not up to date.

pod install --repo-update

Step Three

You can import the FinotesWatchosCore to your code using the import statement below.

#import <FinotesWatch/Fn.h>

You need to call the [Fn initialize:self] function in your ExtensionDelegate applicationDidFinishLaunching

#import <FinotesWatch/Fn.h>

- (void)applicationDidFinishLaunching {
    
    [Fn initialize:self];
}

Testing Integration

Now that the basic integration of Finotes framework is complete,
Let us make sure that the dashboard and SDK are in sync.

#import <FinotesWatch/Fn.h>
#import <FinotesWatch/Severity.h>


- (void)applicationDidFinishLaunching {
    
    [Fn initialize:self];

    [Fn test];
}

Once you are ready to release the application, you need to back up the dSYM file to symbolicate the crashes as they are reported. Locating dSYM file.

Finotes Framework can detect all WKInterfaceController level leaks.
You need to override your WKInterfaceController from ObservableInterfaceController provided by Finotes.

@interface HealthInsightsInterfaceController : ObservableInterfaceController

@end

AFNetworking

Incase you are using AFNetworking, then you need to add the below code in your NSURLSessionConfiguration. The part we are interested is

NSURLSessionConfiguration *configuration = [NSURLSessionConfiguration 
                defaultSessionConfiguration];
configuration.protocolClasses = [Fn getProtocols:[configuration.protocolClasses mutableCopy] ];

AFHTTPRequestOperationManager

If you try to use ‘AFHTTPRequestOperationManager’, your app might crash. ‘AFHTTPRequestOperationManager’ is outdated in AFNetworking 3.x, we suggest you migrate to ‘NSURLSessionConfiguration’. You can find out, how to migrate to ‘NSURLSessionConfiguration’ here.

NSURLSessionConfiguration *configuration = [NSURLSessionConfiguration 
                defaultSessionConfiguration];
configuration.protocolClasses = [Fn getProtocols:[configuration.protocolClasses mutableCopy] ];

As Finotes reports API call issues, each issue is tagged with corresponding request response headers, request body and associated parameters.
If header fields contain any sensitive data, Finotes provides a global and easy mechanism to mask such header fields using maskHeaders in info.plist file as shown in code snippet.
You may provide 1 or more header keys in the 'maskHeaders' field.

<key>MaskHeaders</key>
<array>
<string>Header-Key</string>
<string>Another-Header-Key</string>
</array>

When API call issues are reported, different urls are created as separate ticket.
This can cause large number of tickets generated for the same API incase the url contains an id or any other dynamic path component.

Use URLPatterns key in info.plist to specify the urls that contains dynamic path component.
Wrap the corresponding dynamic path component or id inside '{}'.

With basic integration, Finotes will track and report NSException based uncaught exceptions to Finotes dasboard automatically.

Block Finotes from Reporting Crashes

In case developers want to prevent Finotes from reporting such uncaught exceptions that causes app to force close, add key PreventCrashes to your info.plist file.

Finotes Framework is capable of detecting InterfaceController loading delay by extending from ObservableInterfaceController, a custom class provided by Finotes.
If the extended InterfaceController takes more than 4 seconds to load then it will be raised as a bug report.

@interface HealthInsightsInterfaceController : ObservableInterfaceController

@end

Any exceptions that may have already been caught using @try{}@catch{} needs to be reported as they might prevent the application from crashing, but at the same time can make app unstable if gone unreported.

@try{
    [self fetchUserDetails];
}@catch(NSException *exception){
    [Fn reportExceptionAt:self withException:exception 
                    withSeverity:FATAL];
}

You can report custom issues using the [Fn reportIssueAt:] API.

//Payment gateway delegate methods.
-(void) paymentCompleted:(NSString *) userIdentifier forType:(NSInteger) type{

}

-(void) paymentFailed:(NSString *) userIdentifier forReason:(NSString *) reason{

    [Fn setActivityMarkerAt:self marker:[NSString stringWithFormat:@"User id %@", userIdentifier]];

    [Fn reportIssueAt:self withShortDescription:@"Payment failed" withDescription:reason];
    
}

Finotes will report all return value issues, exceptions and execution delays that may arise during function execution using [Fn call].

    [self getUserNameFromDb:@"123-sd-12"]
}

-(NSString *) getUserNameFromDb:(NSString *) userId {
    NSString *userName = [[User findById:userId] name];
    return userName;
}

#import <FinotesWatch/Observer.h>
#import <FinotesWatch/Fn.h>


    [Fn call:@selector(getUserNameFromDb:) target:self withParameters:@"123-sd-12"];
}

-(NSString *) getUserNameFromDb:(NSString *) userId {
    NSString *userName = [[User findById:userId] name];
    return userName;
}

Notes:

Observe fields

You can make use of expectedExecutionTime, severity, expectNull fields in Observer parameter of

[Fn call: target: observer:observer withParameters: ];

expectedExecutionTime

Incase, we have a function that may take more than 1000 milliseconds(default value) for execution then use this field in Observer to provide an ideal execution time.
Supplying proper values in Observer parameter will help Finotes raise better issue reports.

#import <FinotesWatch/Observer.h>
#import <FinotesWatch/Fn.h>



    Observer *observer =  [[Fn observe] expectedExecutionTime:1400];
    NSString *userName = [Fn call:@selector(getUserNameFromDb:) target:self 
                    observer:observer withParameters:@"123-sd-12"];
}

-(NSString *) getUserNameFromDb:(NSString *) userId {
    NSString *userName = [[User findById:userId] name];
    return userName;
}

expectNull

If function returns an object and return value could be NULL, then set this field to true to prevent Finotes from raising an issue when function returns NULL.
By default field is false, and issue will be raised if function returns NULL.

severity

Sets severity level of issues reported from a function using this field.
All issues raised from a function will have the same severity level, set to it using Observer parameter.
By default severity is MAJOR.

Finotes has the ability to invoke code level functions and report any issues that may arise from it.

Feature tracking allows developers to track a particular feature in watchOS app by chaining 2 or more functions invoked by Finotes.
Let us take the example of Chat feature in a typical watchOS application.
The function at the time of clicking the send button 'sendChat' and 'onChatSent' success function after the items as been added to the cart needs to be invoked using Finotes.
The Finotes looks for 'onChatSent' function execution after the execution of 'sendChat', if the 'onChatSent' is not executed within in 10000 milliseconds then a corresponding issue will be raised.

#import <FinotesWatch/Observer.h>
#import <FinotesWatch/Fn.h>


- (void) sendChatClicked:(UITapGestureRecognizer *)recognizer {

    // Here function 'onChatSent:' is 
    // expected to be called in under '10000' milliseconds.
    Observer *observer =  [[[Fn observe] expectedChainedExecutionTime:10000]  
            nextFunctionSignature:
                @selector(onChatSent:) 
            inClass:[self class]];
    [Fn call:@selector(sendChat:) target:self observer:observer withParameters:chatMessage];
}

- (Boolean) sendChat:(NSString *) message {
    if([self isValid:message]){
        [self syncMessage:message];
    }
    return false;
}

- (void) onChatSent:(NSString *)chatMessageId {
    [self chatSyncConfirmed:chatMessageId];
}

Notes:

Observer fields

You can make use of nextFunctionSignature, inClass, expectedChainedExecutionTime fields in Observer parameter to chain 2 or more functions.

expectedExecutionTime

Overrides time needed to execute second function after execution of first function.
By default the time between function executions is set to 2000 milliseconds.

nextFunctionSignature

Signature of the second function that is to be chained with the current function.

inClass

Class where second function is defined that is to be chained with the current function.

This feature will be activated only in debug framework.

With a single line, finotes can track frame rate issues that might occur in watchOS application

#import <FinotesWatch/Fn.h>

- (void)applicationDidFinishLaunching {

    [Fn initialize:application];
    [Fn enableFrameRateDetection];
}

Activity markers are events that occur in an application during runtime.

You can set custom activity markers in the project using [Fn setActivityMarkerAt]. These markers will be shown as the activity trail when an issue is reported.

Markers are displayed in their chronological order.
Only when an issue is raised, the activity markers are sent to the server.

[Fn setActivityMarkerAt:self marker:@"clicked on payment_package_two"];

ExtensionDelegate:app loaded                            11:19:24:469	45.79% FREE MEMORY 
Controller:user loaded                                  11:19:24:708	44.39%
Controller:user authenticated                           11:19:27:012	45.19%
Controller:clicked on payment_package_two               11:20:24:235	55.20%

Once the user login is complete, you can set any custom user identifier with finotes, This identifier will be tagged with all issue reports raised in Finotes dashboard.
If this API is invoked multiple times, the latest identifier will be used with each issue report.

[Fn updateUserDataWithUniqueIdentifier:userId];

You can listen for and access every issue in realtime using the Fn.listenForIssue() API.
You need to add the listener in your ExtensionDelegate class.

   [Fn listenForIssues:@selector(issueFound:) atTarget:self];
}

(void) issueFound:(Issue *) issue {

}

Developers can whitelist crash reporting by adding WhitelistCrashes key in info.plist file.
Once whitelisted, only exceptions that are listed in info.plist will be reported by Finotes.