Add setting to AppRTCMobile for iOS, that can change capture resolution.

webrtc/examples/objc/AppRTCMobile/ios/ARDMediaConstraintsModel.h

Index: webrtc/examples/objc/AppRTCMobile/ios/ARDMediaConstraintsModel.h
diff --git a/webrtc/examples/objc/AppRTCMobile/ios/ARDMediaConstraintsModel.h b/webrtc/examples/objc/AppRTCMobile/ios/ARDMediaConstraintsModel.h
new file mode 100644
index 0000000000000000000000000000000000000000..eaf93861205fc85b4ce770d9da02ec4e9b291b22
--- /dev/null
+++ b/webrtc/examples/objc/AppRTCMobile/ios/ARDMediaConstraintsModel.h
@@ -0,0 +1,57 @@
+/*
+ *  Copyright 2016 The WebRTC Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+/**
+ * Model class for user defined media constraints.
+ *
+ * Currently used for streaming media constraints only.
+ * In future audio media constraints support can be added as well.
+ * Offers list of avaliable video resolutions that can construct streaming media constraint.
+ * Exposes methods for reading and storing media constraints from persistent store.
+ * Also translates current user defined media constraint into RTCMediaConstraints
+ * dictionary.
+ */
+@interface ARDMediaConstraintsModel : NSObject
+
+/**
+ * Returns array of available capture resoultions.
+ *
+ * The capture resolutions are represented as strings in the following format
+ * [width]x[height]
+ */
+- (NSArray<NSString *> *)availableVideoResoultionsMediaConstraints;
+
+/**
+ * Returns current video resolution media constraint string.
+ * If no constraint is in store, default value of 640x480 is returned.
+ * When defaulting to value, the default is saved in store for consistency reasons.
+ */
+- (NSString *)currentVideoResoultionConstraintFromStore;

[magjed_webrtc, 2016/10/31 19:26:39]

Wouldn't it be more convenient to represent the resolution as some kind of
struct { int width; int height; } POD?

[daniela-webrtc, 2016/11/01 09:51:12]

It would make things cleaner for sure.  Sadly, string-int conversions are not
straight forward in ObjC, as oppose to Java for instance.  And it would require
additional helper method and classes to handle the int<->nsstring conversion.
Integers are simple types and they cannot be used for storing in
NSUserDefautlts, they cannot be used in NSDictionary and cannot be used as
DataSource for the Table view either.
That's why I've decided to stick to string representation everywhere.

[magjed_webrtc, 2016/11/01 12:06:09]

I thought we could just do this in ObjC:
someString.integerValue
@(someInt).stringValue
where the types are NSInteger and NSString. I think it would be more convenient
to convert to some int-based format as early as possible, i.e. in the store, so
that we can use ints as much as possible in the rest of the code. When we fill
in the dictionary we convert it back to strings like this:
mediaConstraintsDictionary = @{
  kRTCMediaConstraintsMinWidth : @(widthConstraint).stringValue,
  kRTCMediaConstraintsMinHeight : @(heightConstraint).stringValue
};

[daniela-webrtc, 2016/11/01 14:43:32]

Sorry I think I didn't elaborate my thinking well enough previously.
Yes, we can use the NSNumber literal to convert int-NSNumber-NSString. But
that's not the main problem. 
The issue is that the resolution type representation should be serializable, i.e
compatible to be stored to NSUserDefaults (conform to NSCopying protocol). That
means we can
1. Create new class to represent the video resolution. Implement methods of
NSCopying and implement methods for the need of the data source in the settings
view controller (like toString or similar).
2. Use struct representation for the video resolution in  the model. Then we'd
need to have methods (either in the model or the store) to serialize the struct
into a type that can be stored (like NSString or NSDictionary).
Additionally provide some kind of toString class again that would be suitable
for the data source in the settings view controller.

Given the size of the CL I decided to go the simplest route possible (NSString
eeevrywhere) :) Let me know if you think it's worth adding more code to do this
right away.

[magjed_webrtc, 2016/11/01 17:52:20]

Alright, let's keep it as strings for now if you think that's simpler. I don't
know ObjC well enough to know how much boilerplate it will require to add a
resolution class with NSCopying and toString. I was hoping a resolution class
would simplify the code since we could then remove e.g.
currentVideoResolutionWidthFromStore/currentVideoResolutionHeighFromStore/videoResolutionComponentAtIndex
that already do string parsing. I think we might need a resolution class in the
future anyway when we refactor AVFoundationVideoCapturer so that we can
enumerate the available formats properly in
availableVideoResoultionsMediaConstraints.

+
+/**
+ * Stores the provided video resolution media constraint string into the store.
+ *
+ * @param constraint the string to be stored.
+ */
+- (void)storeVideoResoultionConstraint:(NSString *)constraint;
+
+/**
+ * Converts the current media constraints from store into dictionary with RTCMediaConstraints
+ * values.
+ *
+ * @return NSDictionary with RTC width and height parameters
+ */
+- (nullable NSDictionary *)currentMediaConstraintFromStoreAsRTCDictionary;
+
+@end
+NS_ASSUME_NONNULL_END